bouquin 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

bouquin/db.py

@@ -1,15 +1,23 @@
 from __future__ import annotations
 
+import csv
+import html
+import json
+import os
+
 from dataclasses import dataclass
 from pathlib import Path
-
 from sqlcipher3 import dbapi2 as sqlite
+from typing import List, Sequence, Tuple
+
+Entry = Tuple[str, str]
 
 
 @dataclass
 class DBConfig:
     path: Path
     key: str
+    idle_minutes: int = 15  # 0 = never lock
 
 
 class DBManager:
@@ -21,9 +29,9 @@ class DBManager:
         # Ensure parent dir exists
         self.cfg.path.parent.mkdir(parents=True, exist_ok=True)
         self.conn = sqlite.connect(str(self.cfg.path))
+        self.conn.row_factory = sqlite.Row
         cur = self.conn.cursor()
         cur.execute(f"PRAGMA key = '{self.cfg.key}';")
-        cur.execute("PRAGMA cipher_compatibility = 4;")
         cur.execute("PRAGMA journal_mode = WAL;")
         self.conn.commit()
         try:
@@ -103,14 +111,116 @@ class DBManager:
     def search_entries(self, text: str) -> list[str]:
         cur = self.conn.cursor()
         pattern = f"%{text}%"
-        cur.execute("SELECT * FROM entries WHERE TRIM(content) LIKE ?", (pattern,))
-        return [r for r in cur.fetchall()]
+        return cur.execute(
+            "SELECT * FROM entries WHERE TRIM(content) LIKE ?", (pattern,)
+        ).fetchall()
 
     def dates_with_content(self) -> list[str]:
         cur = self.conn.cursor()
         cur.execute("SELECT date FROM entries WHERE TRIM(content) <> '';")
         return [r[0] for r in cur.fetchall()]
 
+    def get_all_entries(self) -> List[Entry]:
+        cur = self.conn.cursor()
+        rows = cur.execute("SELECT date, content FROM entries ORDER BY date").fetchall()
+        return [(row["date"], row["content"]) for row in rows]
+
+    def export_json(
+        self, entries: Sequence[Entry], file_path: str, pretty: bool = True
+    ) -> None:
+        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=(",", ":"))
+
+    def export_csv(self, entries: Sequence[Entry], file_path: str) -> None:
+        # 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)
+            writer.writerow(["date", "content"])  # header
+            writer.writerows(entries)
+
+    def export_txt(
+        self,
+        entries: Sequence[Entry],
+        file_path: str,
+        separator: str = "\n\n— — — — —\n\n",
+        strip_html: bool = True,
+    ) -> None:
+        import re, html as _html
+
+        # Precompiled patterns
+        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"<[^>]+>")
+        WS_ENDS_RE = re.compile(r"[ \\t]+\\n")
+        MULTINEWLINE_RE = re.compile(r"\\n{3,}")
+
+        def _strip(s: str) -> str:
+            # 1) Remove <style> and <script> blocks *including their contents*
+            s = STYLE_SCRIPT_RE.sub("", s)
+            # 2) Remove HTML comments
+            s = COMMENT_RE.sub("", s)
+            # 3) Turn some block-ish boundaries into newlines before removing tags
+            s = BR_RE.sub("\n", s)
+            s = BLOCK_END_RE.sub("\n", s)
+            # 4) Drop remaining tags
+            s = TAG_RE.sub("", s)
+            # 5) Unescape entities (&nbsp; etc.)
+            s = _html.unescape(s)
+            # 6) Tidy whitespace
+            s = WS_ENDS_RE.sub("\n", s)
+            s = MULTINEWLINE_RE.sub("\n\n", s)
+            return s.strip()
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            for i, (d, c) in enumerate(entries):
+                body = _strip(c) if strip_html else c
+                f.write(f"{d}\n{body}\n")
+                if i < len(entries) - 1:
+                    f.write(separator)
+
+    def export_html(
+        self, entries: Sequence[Entry], file_path: str, title: str = "Entries export"
+    ) -> None:
+        parts = [
+            "<!doctype html>",
+            '<html lang="en">',
+            '<meta charset="utf-8">',
+            f"<title>{html.escape(title)}</title>",
+            "<style>body{font:16px/1.5 system-ui,Segoe UI,Roboto,Helvetica,Arial,sans-serif;padding:24px;max-width:900px;margin:auto;}",
+            "article{padding:16px 0;border-bottom:1px solid #ddd;} time{font-weight:600;color:#333;} section{margin-top:8px;}</style>",
+            "<body>",
+            f"<h1>{html.escape(title)}</h1>",
+        ]
+        for d, c in entries:
+            parts.append(
+                f"<article><header><time>{html.escape(d)}</time></header><section>{c}</section></article>"
+            )
+        parts.append("</body></html>")
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(parts))
+
+    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 close(self) -> None:
         if self.conn is not None:
             self.conn.close()

bouquin/editor.py

@@ -2,22 +2,144 @@ from __future__ import annotations
 
 from PySide6.QtGui import (
     QColor,
+    QDesktopServices,
     QFont,
     QFontDatabase,
     QTextCharFormat,
+    QTextCursor,
     QTextListFormat,
     QTextBlockFormat,
 )
-from PySide6.QtCore import Slot
+from PySide6.QtCore import Qt, QUrl, Signal, Slot, QRegularExpression
 from PySide6.QtWidgets import QTextEdit
 
 
 class Editor(QTextEdit):
-    def __init__(self):
-        super().__init__()
+    linkActivated = Signal(str)
+
+    _URL_RX = QRegularExpression(r"(https?://[^\s<>\"]+|www\.[^\s<>\"]+)")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         tab_w = 4 * self.fontMetrics().horizontalAdvance(" ")
         self.setTabStopDistance(tab_w)
 
+        self.setTextInteractionFlags(
+            Qt.TextInteractionFlag.TextEditorInteraction
+            | Qt.TextInteractionFlag.LinksAccessibleByMouse
+            | Qt.TextInteractionFlag.LinksAccessibleByKeyboard
+        )
+
+        self.setAcceptRichText(True)
+
+        # Turn raw URLs into anchors
+        self._linkifying = False
+        self.textChanged.connect(self._linkify_document)
+        self.viewport().setMouseTracking(True)
+
+    def _linkify_document(self):
+        if self._linkifying:
+            return
+        self._linkifying = True
+
+        doc = self.document()
+        cur = QTextCursor(doc)
+        cur.beginEditBlock()
+
+        block = doc.begin()
+        while block.isValid():
+            text = block.text()
+            it = self._URL_RX.globalMatch(text)
+            while it.hasNext():
+                m = it.next()
+                start = block.position() + m.capturedStart()
+                end = start + m.capturedLength()
+
+                cur.setPosition(start)
+                cur.setPosition(end, QTextCursor.KeepAnchor)
+
+                fmt = cur.charFormat()
+                if fmt.isAnchor():  # already linkified; skip
+                    continue
+
+                href = m.captured(0)
+                if href.startswith("www."):
+                    href = "https://" + href
+
+                fmt.setAnchor(True)
+                # Qt 6: use setAnchorHref; for compatibility, also set names.
+                try:
+                    fmt.setAnchorHref(href)
+                except AttributeError:
+                    fmt.setAnchorNames([href])
+
+                fmt.setFontUnderline(True)
+                fmt.setForeground(Qt.blue)
+                cur.setCharFormat(fmt)
+
+            block = block.next()
+
+        cur.endEditBlock()
+        self._linkifying = False
+
+    def mouseReleaseEvent(self, e):
+        if e.button() == Qt.LeftButton and (e.modifiers() & Qt.ControlModifier):
+            href = self.anchorAt(e.pos())
+            if href:
+                QDesktopServices.openUrl(QUrl.fromUserInput(href))
+                self.linkActivated.emit(href)
+                return
+        super().mouseReleaseEvent(e)
+
+    def mouseMoveEvent(self, e):
+        if (e.modifiers() & Qt.ControlModifier) and self.anchorAt(e.pos()):
+            self.viewport().setCursor(Qt.PointingHandCursor)
+        else:
+            self.viewport().setCursor(Qt.IBeamCursor)
+        super().mouseMoveEvent(e)
+
+    def keyPressEvent(self, e):
+        key = e.key()
+
+        # Pre-insert: stop link/format bleed for “word boundary” keys
+        if key in (Qt.Key_Space, Qt.Key_Tab):
+            self._break_anchor_for_next_char()
+            return super().keyPressEvent(e)
+
+        # When pressing Enter/return key, insert first, then neutralise the empty block’s inline format
+        if key in (Qt.Key_Return, Qt.Key_Enter):
+            super().keyPressEvent(e)  # create the new (possibly empty) paragraph
+
+            # If we're on an empty block, clear the insertion char format so the
+            # *next* Enter will create another new line (not consume the press to reset formatting).
+            c = self.textCursor()
+            block = c.block()
+            if block.length() == 1:
+                self._clear_insertion_char_format()
+            return
+
+        return super().keyPressEvent(e)
+
+    def _clear_insertion_char_format(self):
+        """Reset inline typing format (keeps lists, alignment, margins, etc.)."""
+        nf = QTextCharFormat()
+        self.setCurrentCharFormat(nf)
+
+    def _break_anchor_for_next_char(self):
+        c = self.textCursor()
+        fmt = c.charFormat()
+        if fmt.isAnchor() or fmt.fontUnderline() or fmt.foreground().style() != 0:
+            # clone, then strip just the link-specific bits so the next char is plain text
+            nf = QTextCharFormat(fmt)
+            nf.setAnchor(False)
+            nf.setFontUnderline(False)
+            nf.clearForeground()
+            try:
+                nf.setAnchorHref("")
+            except AttributeError:
+                nf.setAnchorNames([])
+            self.setCurrentCharFormat(nf)
+
     def merge_on_sel(self, fmt):
         """
         Sets the styling on the selected characters.
@@ -28,9 +150,15 @@ class Editor(QTextEdit):
         cursor.mergeCharFormat(fmt)
         self.mergeCurrentCharFormat(fmt)
 
-    @Slot(QFont.Weight)
-    def apply_weight(self, weight):
+    @Slot()
+    def apply_weight(self):
+        cur = self.currentCharFormat()
         fmt = QTextCharFormat()
+        weight = (
+            QFont.Weight.Normal
+            if cur.fontWeight() == QFont.Weight.Bold
+            else QFont.Weight.Bold
+        )
         fmt.setFontWeight(weight)
         self.merge_on_sel(fmt)
 

bouquin/key_prompt.py

@@ -14,8 +14,8 @@ class KeyPrompt(QDialog):
     def __init__(
         self,
         parent=None,
-        title: str = "Unlock database",
-        message: str = "Enter SQLCipher key",
+        title: str = "Enter key",
+        message: str = "Enter key",
     ):
         super().__init__(parent)
         self.setWindowTitle(title)

bouquin/main_window.py

@@ -1,18 +1,26 @@
 from __future__ import annotations
 
+import os
 import sys
 
-from PySide6.QtCore import QDate, QTimer, Qt
+from pathlib import Path
+from PySide6.QtCore import QDate, QTimer, Qt, QSettings, Slot, QUrl, QEvent
 from PySide6.QtGui import (
     QAction,
+    QCursor,
+    QDesktopServices,
     QFont,
+    QGuiApplication,
     QTextCharFormat,
 )
 from PySide6.QtWidgets import (
     QCalendarWidget,
     QDialog,
+    QFileDialog,
+    QLabel,
     QMainWindow,
     QMessageBox,
+    QPushButton,
     QSizePolicy,
     QSplitter,
     QVBoxLayout,
@@ -23,11 +31,66 @@ from .db import DBManager
 from .editor import Editor
 from .key_prompt import KeyPrompt
 from .search import Search
-from .settings import APP_NAME, load_db_config, save_db_config
+from .settings import APP_ORG, APP_NAME, load_db_config, save_db_config
 from .settings_dialog import SettingsDialog
 from .toolbar import ToolBar
 
 
+class _LockOverlay(QWidget):
+    def __init__(self, parent: QWidget, on_unlock: callable):
+        super().__init__(parent)
+        self.setObjectName("LockOverlay")
+        self.setAttribute(Qt.WA_StyledBackground, True)
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.setGeometry(parent.rect())
+
+        self.setStyleSheet(
+            """
+#LockOverlay { background-color: #ccc; }
+#LockOverlay QLabel { color: #fff; font-size: 18px; }
+#LockOverlay QPushButton {
+    background-color: #f2f2f2;
+    color: #000;
+    padding: 6px 14px;
+    border: 1px solid #808080;
+    border-radius: 6px;
+    font-size: 14px;
+}
+#LockOverlay QPushButton:hover   { background-color: #ffffff; }
+#LockOverlay QPushButton:pressed { background-color: #e6e6e6; }
+"""
+        )
+
+        lay = QVBoxLayout(self)
+        lay.addStretch(1)
+
+        msg = QLabel("Locked due to inactivity")
+        msg.setAlignment(Qt.AlignCenter)
+
+        self._btn = QPushButton("Unlock")
+        self._btn.setFixedWidth(200)
+        self._btn.setCursor(Qt.PointingHandCursor)
+        self._btn.setAutoDefault(True)
+        self._btn.setDefault(True)
+        self._btn.clicked.connect(on_unlock)
+
+        lay.addWidget(msg, 0, Qt.AlignCenter)
+        lay.addWidget(self._btn, 0, Qt.AlignCenter)
+        lay.addStretch(1)
+
+        self.hide()  # start hidden
+
+    # keep overlay sized with its parent
+    def eventFilter(self, obj, event):
+        if obj is self.parent() and event.type() in (QEvent.Resize, QEvent.Show):
+            self.setGeometry(obj.rect())
+        return False
+
+    def showEvent(self, e):
+        super().showEvent(e)
+        self._btn.setFocus()
+
+
 class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
@@ -35,9 +98,18 @@ class MainWindow(QMainWindow):
         self.setMinimumSize(1000, 650)
 
         self.cfg = load_db_config()
-        # Always prompt for the key (we never store it)
-        if not self._prompt_for_key_until_valid():
-            sys.exit(1)
+        if not os.path.exists(self.cfg.path):
+            # Fresh database/first time use, so guide the user re: setting a key
+            first_time = True
+        else:
+            first_time = False
+
+        # Prompt for the key unless it is found in config
+        if not self.cfg.key:
+            if not self._prompt_for_key_until_valid(first_time):
+                sys.exit(1)
+        else:
+            self._try_connect()
 
         # ---- UI: Left fixed panel (calendar) + right editor -----------------
         self.calendar = QCalendarWidget()
@@ -62,18 +134,18 @@ class MainWindow(QMainWindow):
         self.editor = Editor()
 
         # Toolbar for controlling styling
-        tb = ToolBar()
-        self.addToolBar(tb)
+        self.toolBar = ToolBar()
+        self.addToolBar(self.toolBar)
         # Wire toolbar intents to editor methods
-        tb.boldRequested.connect(self.editor.apply_weight)
-        tb.italicRequested.connect(self.editor.apply_italic)
-        tb.underlineRequested.connect(self.editor.apply_underline)
-        tb.strikeRequested.connect(self.editor.apply_strikethrough)
-        tb.codeRequested.connect(self.editor.apply_code)
-        tb.headingRequested.connect(self.editor.apply_heading)
-        tb.bulletsRequested.connect(self.editor.toggle_bullets)
-        tb.numbersRequested.connect(self.editor.toggle_numbers)
-        tb.alignRequested.connect(self.editor.setAlignment)
+        self.toolBar.boldRequested.connect(self.editor.apply_weight)
+        self.toolBar.italicRequested.connect(self.editor.apply_italic)
+        self.toolBar.underlineRequested.connect(self.editor.apply_underline)
+        self.toolBar.strikeRequested.connect(self.editor.apply_strikethrough)
+        self.toolBar.codeRequested.connect(self.editor.apply_code)
+        self.toolBar.headingRequested.connect(self.editor.apply_heading)
+        self.toolBar.bulletsRequested.connect(self.editor.toggle_bullets)
+        self.toolBar.numbersRequested.connect(self.editor.toggle_numbers)
+        self.toolBar.alignRequested.connect(self.editor.setAlignment)
 
         split = QSplitter()
         split.addWidget(left_panel)
@@ -85,20 +157,42 @@ class MainWindow(QMainWindow):
         lay.addWidget(split)
         self.setCentralWidget(container)
 
+        # Idle lock setup
+        self._idle_timer = QTimer(self)
+        self._idle_timer.setSingleShot(True)
+        self._idle_timer.timeout.connect(self._enter_lock)
+        self._apply_idle_minutes(getattr(self.cfg, "idle_minutes", 15))
+        self._idle_timer.start()
+
+        # full-window overlay that sits on top of the central widget
+        self._lock_overlay = _LockOverlay(self.centralWidget(), self._on_unlock_clicked)
+        self.centralWidget().installEventFilter(self._lock_overlay)
+
+        self._locked = False
+
+        # reset idle timer on any key press anywhere in the app
+        from PySide6.QtWidgets import QApplication
+
+        QApplication.instance().installEventFilter(self)
+
         # Status bar for feedback
         self.statusBar().showMessage("Ready", 800)
 
         # Menu bar (File)
         mb = self.menuBar()
-        file_menu = mb.addMenu("&Application")
+        file_menu = mb.addMenu("&File")
         act_save = QAction("&Save", self)
         act_save.setShortcut("Ctrl+S")
         act_save.triggered.connect(lambda: self._save_current(explicit=True))
         file_menu.addAction(act_save)
-        act_settings = QAction("S&ettings", self)
-        act_settings.setShortcut("Ctrl+E")
+        act_settings = QAction("Settin&gs", self)
+        act_settings.setShortcut("Ctrl+G")
         act_settings.triggered.connect(self._open_settings)
         file_menu.addAction(act_settings)
+        act_export = QAction("&Export", self)
+        act_export.setShortcut("Ctrl+E")
+        act_export.triggered.connect(self._export)
+        file_menu.addAction(act_export)
         file_menu.addSeparator()
         act_quit = QAction("&Quit", self)
         act_quit.setShortcut("Ctrl+Q")
@@ -128,6 +222,21 @@ class MainWindow(QMainWindow):
         nav_menu.addAction(act_today)
         self.addAction(act_today)
 
+        # Help menu with drop-down
+        help_menu = mb.addMenu("&Help")
+        act_docs = QAction("Documentation", self)
+        act_docs.setShortcut("Ctrl+D")
+        act_docs.setShortcutContext(Qt.ApplicationShortcut)
+        act_docs.triggered.connect(self._open_docs)
+        help_menu.addAction(act_docs)
+        self.addAction(act_docs)
+        act_bugs = QAction("Report a bug", self)
+        act_bugs.setShortcut("Ctrl+R")
+        act_bugs.setShortcutContext(Qt.ApplicationShortcut)
+        act_bugs.triggered.connect(self._open_bugs)
+        help_menu.addAction(act_bugs)
+        self.addAction(act_bugs)
+
         # Autosave
         self._dirty = False
         self._save_timer = QTimer(self)
@@ -139,6 +248,10 @@ class MainWindow(QMainWindow):
         self._load_selected_date()
         self._refresh_calendar_marks()
 
+        # Restore window position from settings
+        self.settings = QSettings(APP_ORG, APP_NAME)
+        self._restore_window_position()
+
     def _try_connect(self) -> bool:
         """
         Try to connect to the database.
@@ -155,12 +268,18 @@ class MainWindow(QMainWindow):
             return False
         return ok
 
-    def _prompt_for_key_until_valid(self) -> bool:
+    def _prompt_for_key_until_valid(self, first_time: bool) -> bool:
         """
         Prompt for the SQLCipher key.
         """
+        if first_time:
+            title = "Set an encryption key"
+            message = "Bouquin encrypts your data.\n\nPlease create a strong passphrase to encrypt the notebook.\n\nYou can always change it later!"
+        else:
+            title = "Unlock encrypted notebook"
+            message = "Enter your key to unlock the notebook"
         while True:
-            dlg = KeyPrompt(self, message="Enter a key to unlock the notebook")
+            dlg = KeyPrompt(self, title, message)
             if dlg.exec() != QDialog.Accepted:
                 return False
             self.cfg.key = dlg.key()
@@ -206,6 +325,8 @@ class MainWindow(QMainWindow):
         self._dirty = False
         # track which date the editor currently represents
         self._active_date_iso = date_iso
+        qd = QDate.fromString(date_iso, "yyyy-MM-dd")
+        self.calendar.setSelectedDate(qd)
 
     def _on_text_changed(self):
         self._dirty = True
@@ -265,24 +386,193 @@ class MainWindow(QMainWindow):
 
     def _open_settings(self):
         dlg = SettingsDialog(self.cfg, self.db, self)
-        if dlg.exec() == QDialog.Accepted:
-            new_cfg = dlg.config
-            if new_cfg.path != self.cfg.path:
-                # Save the new path to the notebook
-                self.cfg.path = new_cfg.path
-                save_db_config(self.cfg)
-                self.db.close()
-                # Prompt again for the key for the new path
-                if not self._prompt_for_key_until_valid():
-                    QMessageBox.warning(
-                        self, "Reopen failed", "Could not unlock database at new path."
-                    )
-                    return
-                self._load_selected_date()
-                self._refresh_calendar_marks()
+        if dlg.exec() != QDialog.Accepted:
+            return
+
+        new_cfg = dlg.config
+        old_path = self.cfg.path
+
+        # Update in-memory config from the dialog
+        self.cfg.path = new_cfg.path
+        self.cfg.key = new_cfg.key
+        self.cfg.idle_minutes = getattr(new_cfg, "idle_minutes", self.cfg.idle_minutes)
+
+        # Persist once
+        save_db_config(self.cfg)
+
+        # Apply idle setting immediately (restart the timer with new interval if it changed)
+        self._apply_idle_minutes(self.cfg.idle_minutes)
 
+        # If the DB path changed, reconnect
+        if self.cfg.path != old_path:
+            self.db.close()
+            if not self._prompt_for_key_until_valid(first_time=False):
+                QMessageBox.warning(
+                    self, "Reopen failed", "Could not unlock database at new path."
+                )
+                return
+            self._load_selected_date()
+            self._refresh_calendar_marks()
+
+    def _restore_window_position(self):
+        geom = self.settings.value("main/geometry", None)
+        state = self.settings.value("main/windowState", None)
+        was_max = self.settings.value("main/maximized", False, type=bool)
+
+        if geom is not None:
+            self.restoreGeometry(geom)
+            if state is not None:
+                self.restoreState(state)
+            if not self._rect_on_any_screen(self.frameGeometry()):
+                self._move_to_cursor_screen_center()
+        else:
+            # First run: place window on the screen where the mouse cursor is.
+            self._move_to_cursor_screen_center()
+
+        # If it was maximized, do that AFTER the window exists in the event loop.
+        if was_max:
+            QTimer.singleShot(0, self.showMaximized)
+
+    def _rect_on_any_screen(self, rect):
+        for sc in QGuiApplication.screens():
+            if sc.availableGeometry().intersects(rect):
+                return True
+        return False
+
+    def _move_to_cursor_screen_center(self):
+        screen = (
+            QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
+        )
+        r = screen.availableGeometry()
+        # Center the window in that screen’s available area
+        self.move(r.center() - self.rect().center())
+
+    @Slot()
+    def _export(self):
+        try:
+            self.export_dialog()
+        except Exception as e:
+            QMessageBox.critical(self, "Export failed", str(e))
+
+    def export_dialog(self) -> None:
+        filters = "Text (*.txt);;" "JSON (*.json);;" "CSV (*.csv);;" "HTML (*.html);;"
+
+        start_dir = os.path.join(os.path.expanduser("~"), "Documents")
+        filename, selected_filter = QFileDialog.getSaveFileName(
+            self, "Export entries", start_dir, filters
+        )
+        if not filename:
+            return  # user cancelled
+
+        default_ext = {
+            "Text (*.txt)": ".txt",
+            "JSON (*.json)": ".json",
+            "CSV (*.csv)": ".csv",
+            "HTML (*.html)": ".html",
+        }.get(selected_filter, ".txt")
+
+        if not Path(filename).suffix:
+            filename += default_ext
+
+        try:
+            entries = self.db.get_all_entries()
+            if selected_filter.startswith("Text"):
+                self.db.export_txt(entries, filename)
+            elif selected_filter.startswith("JSON"):
+                self.db.export_json(entries, filename)
+            elif selected_filter.startswith("CSV"):
+                self.db.export_csv(entries, filename)
+            elif selected_filter.startswith("HTML"):
+                self.bd.export_html(entries, filename)
+            else:
+                self.bd.export_by_extension(entries, filename)
+
+            QMessageBox.information(self, "Export complete", f"Saved to:\n{filename}")
+        except Exception as e:
+            QMessageBox.critical(self, "Export failed", str(e))
+
+    def _open_docs(self):
+        url_str = "https://git.mig5.net/mig5/bouquin/wiki/Help"
+        url = QUrl.fromUserInput(url_str)
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.warning(
+                self, "Open Documentation", f"Couldn't open:\n{url.toDisplayString()}"
+            )
+
+    def _open_bugs(self):
+        url_str = "https://nr.mig5.net/forms/mig5/contact"
+        url = QUrl.fromUserInput(url_str)
+        if not QDesktopServices.openUrl(url):
+            QMessageBox.warning(
+                self, "Open Documentation", f"Couldn't open:\n{url.toDisplayString()}"
+            )
+
+    # Idle handlers
+    def _apply_idle_minutes(self, minutes: int):
+        minutes = max(0, int(minutes))
+        if not hasattr(self, "_idle_timer"):
+            return
+        if minutes == 0:
+            self._idle_timer.stop()
+            # If you’re currently locked, unlock when user disables the timer:
+            if getattr(self, "_locked", False):
+                try:
+                    self._locked = False
+                    if hasattr(self, "_lock_overlay"):
+                        self._lock_overlay.hide()
+                except Exception:
+                    pass
+        else:
+            self._idle_timer.setInterval(minutes * 60 * 1000)
+            if not getattr(self, "_locked", False):
+                self._idle_timer.start()
+
+    def eventFilter(self, obj, event):
+        if event.type() == QEvent.KeyPress and not self._locked:
+            self._idle_timer.start()
+        return super().eventFilter(obj, event)
+
+    def _enter_lock(self):
+        if self._locked:
+            return
+        self._locked = True
+        if self.menuBar():
+            self.menuBar().setEnabled(False)
+        if self.statusBar():
+            self.statusBar().setEnabled(False)
+        tb = getattr(self, "toolBar", None)
+        if tb:
+            tb.setEnabled(False)
+        self._lock_overlay.show()
+        self._lock_overlay.raise_()
+
+    @Slot()
+    def _on_unlock_clicked(self):
+        try:
+            ok = self._prompt_for_key_until_valid(first_time=False)
+        except Exception as e:
+            QMessageBox.critical(self, "Unlock failed", str(e))
+            return
+        if ok:
+            self._locked = False
+            self._lock_overlay.hide()
+            if self.menuBar():
+                self.menuBar().setEnabled(True)
+            if self.statusBar():
+                self.statusBar().setEnabled(True)
+            tb = getattr(self, "toolBar", None)
+            if tb:
+                tb.setEnabled(True)
+            self._idle_timer.start()
+
+    # Close app handler - save window position and database
     def closeEvent(self, event):
         try:
+            # Save window position
+            self.settings.setValue("main/geometry", self.saveGeometry())
+            self.settings.setValue("main/windowState", self.saveState())
+            self.settings.setValue("main/maximized", self.isMaximized())
+            # Ensure we save any last pending edits to the db
             self._save_current()
             self.db.close()
         except Exception:

bouquin/search.py

@@ -80,7 +80,7 @@ class Search(QWidget):
         for date_str, content in rows:
             # Build an HTML fragment around the match and whether to show ellipses
             frag_html, left_ell, right_ell = self._make_html_snippet(
-                content, query, radius=60, maxlen=180
+                content, query, radius=30, maxlen=90
             )
 
             # ---- Per-item widget: date on top, preview row below (with ellipses) ----
@@ -112,7 +112,7 @@ class Search(QWidget):
             preview = QLabel()
             preview.setTextFormat(Qt.TextFormat.RichText)
             preview.setWordWrap(True)
-            preview.setOpenExternalLinks(True)  # keep links in your HTML clickable
+            preview.setOpenExternalLinks(True)
             preview.setText(
                 frag_html
                 if frag_html

bouquin/settings.py

@@ -21,9 +21,13 @@ def get_settings() -> QSettings:
 def load_db_config() -> DBConfig:
     s = get_settings()
     path = Path(s.value("db/path", str(default_db_path())))
-    return DBConfig(path=path, key="")
+    key = s.value("db/key", "")
+    idle = s.value("db/idle_minutes", 15, type=int)
+    return DBConfig(path=path, key=key, idle_minutes=idle)
 
 
 def save_db_config(cfg: DBConfig) -> None:
     s = get_settings()
     s.setValue("db/path", str(cfg.path))
+    s.setValue("db/key", str(cfg.key))
+    s.setValue("db/idle_minutes", str(cfg.idle_minutes))

bouquin/settings_dialog.py

@@ -3,8 +3,12 @@ from __future__ import annotations
 from pathlib import Path
 
 from PySide6.QtWidgets import (
+    QCheckBox,
     QDialog,
     QFormLayout,
+    QFrame,
+    QGroupBox,
+    QLabel,
     QHBoxLayout,
     QVBoxLayout,
     QWidget,
@@ -13,11 +17,15 @@ from PySide6.QtWidgets import (
     QFileDialog,
     QDialogButtonBox,
     QSizePolicy,
+    QSpinBox,
     QMessageBox,
 )
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtGui import QPalette
+
 
 from .db import DBConfig, DBManager
-from .settings import save_db_config
+from .settings import load_db_config, save_db_config
 from .key_prompt import KeyPrompt
 
 
@@ -27,10 +35,11 @@ class SettingsDialog(QDialog):
         self.setWindowTitle("Settings")
         self._cfg = DBConfig(path=cfg.path, key="")
         self._db = db
+        self.key = ""
 
         form = QFormLayout()
         form.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
-        self.setMinimumWidth(520)
+        self.setMinimumWidth(560)
         self.setSizeGripEnabled(True)
 
         self.path_edit = QLineEdit(str(self._cfg.path))
@@ -47,18 +56,88 @@ class SettingsDialog(QDialog):
         h.setStretch(1, 0)
         form.addRow("Database path", path_row)
 
+        # Encryption settings
+        enc_group = QGroupBox("Encryption and Privacy")
+        enc = QVBoxLayout(enc_group)
+        enc.setContentsMargins(12, 8, 12, 12)
+        enc.setSpacing(6)
+
+        # Checkbox to remember key
+        self.save_key_btn = QCheckBox("Remember key")
+        current_settings = load_db_config()
+        self.key = current_settings.key or ""
+        self.save_key_btn.setChecked(bool(self.key))
+        self.save_key_btn.setCursor(Qt.PointingHandCursor)
+        self.save_key_btn.toggled.connect(self.save_key_btn_clicked)
+        enc.addWidget(self.save_key_btn, 0, Qt.AlignLeft)
+
+        # Explanation for remembering key
+        self.save_key_label = QLabel(
+            "If you don't want to be prompted for your encryption key, check this to remember it. "
+            "WARNING: the key is saved to disk and could be recoverable if your disk is compromised."
+        )
+        self.save_key_label.setWordWrap(True)
+        self.save_key_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        # make it look secondary
+        pal = self.save_key_label.palette()
+        pal.setColor(self.save_key_label.foregroundRole(), pal.color(QPalette.Mid))
+        self.save_key_label.setPalette(pal)
+
+        exp_row = QHBoxLayout()
+        exp_row.setContentsMargins(24, 0, 0, 0)  # indent to line up under the checkbox
+        exp_row.addWidget(self.save_key_label)
+        enc.addLayout(exp_row)
+
+        line = QFrame()
+        line.setFrameShape(QFrame.HLine)
+        line.setFrameShadow(QFrame.Sunken)
+        enc.addWidget(line)
+
         # Change key button
         self.rekey_btn = QPushButton("Change key")
+        self.rekey_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
         self.rekey_btn.clicked.connect(self._change_key)
+        enc.addWidget(self.rekey_btn, 0, Qt.AlignLeft)
 
+        self.idle_spin = QSpinBox()
+        self.idle_spin.setRange(0, 240)
+        self.idle_spin.setSingleStep(1)
+        self.idle_spin.setAccelerated(True)
+        self.idle_spin.setSuffix(" min")
+        self.idle_spin.setSpecialValueText("Never")
+        self.idle_spin.setValue(getattr(cfg, "idle_minutes", 15))
+        enc.addWidget(self.idle_spin, 0, Qt.AlignLeft)
+        # Explanation for idle option (autolock)
+        self.idle_spin_label = QLabel(
+            "Bouquin will automatically lock the notepad after this length of time, after which you'll need to re-enter the key to unlock it. "
+            "Set to 0 (never) to never lock."
+        )
+        self.idle_spin_label.setWordWrap(True)
+        self.idle_spin_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
+        # make it look secondary
+        spal = self.idle_spin_label.palette()
+        spal.setColor(self.idle_spin_label.foregroundRole(), spal.color(QPalette.Mid))
+        self.idle_spin_label.setPalette(spal)
+
+        spin_row = QHBoxLayout()
+        spin_row.setContentsMargins(24, 0, 0, 0)  # indent to line up under the spinbox
+        spin_row.addWidget(self.idle_spin_label)
+        enc.addLayout(spin_row)
+
+        # Put the group into the form so it spans the full width nicely
+        form.addRow(enc_group)
+
+        # Buttons
         bb = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
         bb.accepted.connect(self._save)
         bb.rejected.connect(self.reject)
 
+        # Root layout (adjust margins/spacing a bit)
         v = QVBoxLayout(self)
+        v.setContentsMargins(12, 12, 12, 12)
+        v.setSpacing(10)
         v.addLayout(form)
-        v.addWidget(self.rekey_btn)
-        v.addWidget(bb)
+        v.addWidget(bb, 0, Qt.AlignRight)
 
     def _browse(self):
         p, _ = QFileDialog.getSaveFileName(
@@ -71,16 +150,21 @@ class SettingsDialog(QDialog):
             self.path_edit.setText(p)
 
     def _save(self):
-        self._cfg = DBConfig(path=Path(self.path_edit.text()), key="")
+        key_to_save = self.key if self.save_key_btn.isChecked() else ""
+        self._cfg = DBConfig(
+            path=Path(self.path_edit.text()),
+            key=key_to_save,
+            idle_minutes=self.idle_spin.value(),
+        )
         save_db_config(self._cfg)
         self.accept()
 
     def _change_key(self):
-        p1 = KeyPrompt(self, title="Change key", message="Enter new key")
+        p1 = KeyPrompt(self, title="Change key", message="Enter a new encryption key")
         if p1.exec() != QDialog.Accepted:
             return
         new_key = p1.key()
-        p2 = KeyPrompt(self, title="Change key", message="Re-enter new key")
+        p2 = KeyPrompt(self, title="Change key", message="Re-enter the new key")
         if p2.exec() != QDialog.Accepted:
             return
         if new_key != p2.key():
@@ -92,11 +176,27 @@ class SettingsDialog(QDialog):
         try:
             self._db.rekey(new_key)
             QMessageBox.information(
-                self, "Key changed", "The database key was updated."
+                self, "Key changed", "The notebook was re-encrypted with the new key!"
             )
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Could not change key:\n{e}")
 
+    @Slot(bool)
+    def save_key_btn_clicked(self, checked: bool):
+        if checked:
+            if not self.key:
+                p1 = KeyPrompt(
+                    self, title="Enter your key", message="Enter the encryption key"
+                )
+                if p1.exec() != QDialog.Accepted:
+                    self.save_key_btn.blockSignals(True)
+                    self.save_key_btn.setChecked(False)
+                    self.save_key_btn.blockSignals(False)
+                    return
+            self.key = p1.key() or ""
+        else:
+            self.key = ""
+
     @property
     def config(self) -> DBConfig:
         return self._cfg

bouquin/toolbar.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 from PySide6.QtCore import Signal, Qt
-from PySide6.QtGui import QFont, QAction
+from PySide6.QtGui import QAction, QKeySequence, QFont, QFontDatabase
 from PySide6.QtWidgets import QToolBar
 
 
 class ToolBar(QToolBar):
-    boldRequested = Signal(QFont.Weight)
+    boldRequested = Signal()
     italicRequested = Signal()
     underlineRequested = Signal()
     strikeRequested = Signal()
@@ -18,81 +18,131 @@ class ToolBar(QToolBar):
 
     def __init__(self, parent=None):
         super().__init__("Format", parent)
+        self.setObjectName("Format")
+        self.setToolButtonStyle(Qt.ToolButtonTextOnly)
         self._build_actions()
+        self._apply_toolbar_styles()
 
     def _build_actions(self):
-        # Bold
-        bold = QAction("Bold", self)
-        bold.setShortcut("Ctrl+B")
-        bold.triggered.connect(lambda: self.boldRequested.emit(QFont.Weight.Bold))
+        self.actBold = QAction("Bold", self)
+        self.actBold.setShortcut(QKeySequence.Bold)
+        self.actBold.triggered.connect(self.boldRequested)
 
-        italic = QAction("Italic", self)
-        italic.setShortcut("Ctrl+I")
-        italic.triggered.connect(self.italicRequested)
+        self.actItalic = QAction("Italic", self)
+        self.actItalic.setShortcut(QKeySequence.Italic)
+        self.actItalic.triggered.connect(self.italicRequested)
 
-        underline = QAction("Underline", self)
-        underline.setShortcut("Ctrl+U")
-        underline.triggered.connect(self.underlineRequested)
+        self.actUnderline = QAction("Underline", self)
+        self.actUnderline.setShortcut(QKeySequence.Underline)
+        self.actUnderline.triggered.connect(self.underlineRequested)
 
-        strike = QAction("Strikethrough", self)
-        strike.setShortcut("Ctrl+-")
-        strike.triggered.connect(self.strikeRequested)
+        self.actStrike = QAction("Strikethrough", self)
+        self.actStrike.setShortcut("Ctrl+-")
+        self.actStrike.triggered.connect(self.strikeRequested)
 
-        code = QAction("<code>", self)
-        code.setShortcut("Ctrl+`")
-        code.triggered.connect(self.codeRequested)
+        self.actCode = QAction("Inline code", self)
+        self.actCode.setShortcut("Ctrl+`")
+        self.actCode.triggered.connect(self.codeRequested)
 
         # Headings
-        h1 = QAction("H1", self)
-        h1.setShortcut("Ctrl+1")
-        h2 = QAction("H2", self)
-        h2.setShortcut("Ctrl+2")
-        h3 = QAction("H3", self)
-        h3.setShortcut("Ctrl+3")
-        normal = QAction("Normal", self)
-        normal.setShortcut("Ctrl+P")
-
-        h1.triggered.connect(lambda: self.headingRequested.emit(24))
-        h2.triggered.connect(lambda: self.headingRequested.emit(18))
-        h3.triggered.connect(lambda: self.headingRequested.emit(14))
-        normal.triggered.connect(lambda: self.headingRequested.emit(0))
+        self.actH1 = QAction("Heading 1", self)
+        self.actH2 = QAction("Heading 2", self)
+        self.actH3 = QAction("Heading 3", self)
+        self.actNormal = QAction("Normal text", self)
+        self.actH1.setShortcut("Ctrl+1")
+        self.actH2.setShortcut("Ctrl+2")
+        self.actH3.setShortcut("Ctrl+3")
+        self.actNormal.setShortcut("Ctrl+N")
+        self.actH1.triggered.connect(lambda: self.headingRequested.emit(24))
+        self.actH2.triggered.connect(lambda: self.headingRequested.emit(18))
+        self.actH3.triggered.connect(lambda: self.headingRequested.emit(14))
+        self.actNormal.triggered.connect(lambda: self.headingRequested.emit(0))
 
         # Lists
-        bullets = QAction("• Bullets", self)
-        bullets.triggered.connect(self.bulletsRequested)
-        numbers = QAction("1. Numbered", self)
-        numbers.triggered.connect(self.numbersRequested)
+        self.actBullets = QAction("Bulleted list", self)
+        self.actBullets.triggered.connect(self.bulletsRequested)
+        self.actNumbers = QAction("Numbered list", self)
+        self.actNumbers.triggered.connect(self.numbersRequested)
 
         # Alignment
-        left = QAction("Align Left", self)
-        center = QAction("Align Center", self)
-        right = QAction("Align Right", self)
-
-        left.triggered.connect(
-            lambda: self.alignRequested.emit(Qt.AlignmentFlag.AlignLeft)
-        )
-        center.triggered.connect(
-            lambda: self.alignRequested.emit(Qt.AlignmentFlag.AlignHCenter)
+        self.actAlignL = QAction("Align left", self)
+        self.actAlignC = QAction("Align center", self)
+        self.actAlignR = QAction("Align right", self)
+        self.actAlignL.triggered.connect(lambda: self.alignRequested.emit(Qt.AlignLeft))
+        self.actAlignC.triggered.connect(
+            lambda: self.alignRequested.emit(Qt.AlignHCenter)
         )
-        right.triggered.connect(
-            lambda: self.alignRequested.emit(Qt.AlignmentFlag.AlignRight)
+        self.actAlignR.triggered.connect(
+            lambda: self.alignRequested.emit(Qt.AlignRight)
         )
 
         self.addActions(
             [
-                bold,
-                italic,
-                underline,
-                strike,
-                code,
-                h1,
-                h2,
-                h3,
-                normal,
-                bullets,
-                numbers,
-                left,
-                center,
-                right,
+                self.actBold,
+                self.actItalic,
+                self.actUnderline,
+                self.actStrike,
+                self.actCode,
+                self.actH1,
+                self.actH2,
+                self.actH3,
+                self.actNormal,
+                self.actBullets,
+                self.actNumbers,
+                self.actAlignL,
+                self.actAlignC,
+                self.actAlignR,
             ]
         )
+
+    def _apply_toolbar_styles(self):
+        self._style_letter_button(self.actBold, "B", bold=True)
+        self._style_letter_button(self.actItalic, "I", italic=True)
+        self._style_letter_button(self.actUnderline, "U", underline=True)
+        self._style_letter_button(self.actStrike, "S", strike=True)
+
+        # Monospace look for code; use a fixed font
+        code_font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
+        self._style_letter_button(self.actCode, "</>", custom_font=code_font)
+
+        # Headings
+        self._style_letter_button(self.actH1, "H1")
+        self._style_letter_button(self.actH2, "H2")
+        self._style_letter_button(self.actH3, "H3")
+        self._style_letter_button(self.actNormal, "N")
+
+        # Lists
+        self._style_letter_button(self.actBullets, "•")
+        self._style_letter_button(self.actNumbers, "1.")
+
+        # Alignment
+        self._style_letter_button(self.actAlignL, "L")
+        self._style_letter_button(self.actAlignC, "C")
+        self._style_letter_button(self.actAlignR, "R")
+
+    def _style_letter_button(
+        self,
+        action: QAction,
+        text: str,
+        *,
+        bold: bool = False,
+        italic: bool = False,
+        underline: bool = False,
+        strike: bool = False,
+        custom_font: QFont | None = None,
+    ):
+        btn = self.widgetForAction(action)
+        if not btn:
+            return
+        btn.setText(text)
+        f = custom_font if custom_font is not None else QFont(btn.font())
+        if custom_font is None:
+            f.setBold(bold)
+            f.setItalic(italic)
+            f.setUnderline(underline)
+            f.setStrikeOut(strike)
+        btn.setFont(f)
+
+        # Keep accessibility/tooltip readable
+        btn.setToolTip(action.text())
+        btn.setAccessibleName(action.text())

{bouquin-0.1.2.dist-info → bouquin-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.1.2
+Version: 0.1.4
 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
@@ -29,7 +29,7 @@ It uses [SQLCipher bindings](https://pypi.org/project/sqlcipher3-wheels) as a dr
 for SQLite3. This means that the underlying database for the notebook is encrypted at rest.
 
 To increase security, the SQLCipher key is requested when the app is opened, and is not written
-to disk.
+to disk unless the user configures it to be in the settings.
 
 There is deliberately no network connectivity or syncing intended.
 
@@ -39,22 +39,21 @@ There is deliberately no network connectivity or syncing intended.
 
 ## 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
  * Text is HTML with basic styling
  * Search
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
  * Rekey the database (change the password)
-
-
-## Yet to do
-
- * Taxonomy/tagging
- * Export to other formats (plaintext, json, sql etc)
+ * Export the database to json, txt, html or csv
 
 
 ## How to install
 
+Make sure you have `libxcb-cursor0` installed (it may be called something else on non-Debian distributions).
+
 ### From source
 
  * Clone this repo or download the tarball from the releases page

bouquin-0.1.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+bouquin/__init__.py,sha256=-bBNFYOq80A2Egtpo5V5zWJtYOxQfRZFQ_feve5lkFU,23
+bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+bouquin/db.py,sha256=kvwZRP9fcG8V8paAU0iVR7qTYO8gGCq1qb2Wuog0dKE,7922
+bouquin/editor.py,sha256=vPLqysUNinUO6gtJQ8uDxJ_BL-lcaq0IXLStlG63k4E,8042
+bouquin/key_prompt.py,sha256=N5UxgDDnVAaoAIs9AqoydPSRjJ4Likda4-ejlE-lr-Y,1076
+bouquin/main.py,sha256=u7Wm5-9LRZDKkzKkK0W6P4oTtDorrrmtwIJWmQCqsRs,351
+bouquin/main_window.py,sha256=Q6HJjUU4kY05GeaxNEEoqDY79MN4tu2rlBH7qgEYjuY,20835
+bouquin/search.py,sha256=NAgH_FLjFB2i9bJXEfH3ClO8dWg7geYyoHtmLFNkrwA,6478
+bouquin/settings.py,sha256=GpMeJcTjdL1PFumeqdlSOi7nlgGdPTOeRbFadWYFcA0,870
+bouquin/settings_dialog.py,sha256=pgIg2G5O092mPn5EmkKrEgtl-Tyc8dwwCyNSNEAOidA,7256
+bouquin/toolbar.py,sha256=i8uNhcAyYczVKPgSgk6tNJ63XxqlhPjLNpjzfM9NDC0,5401
+bouquin-0.1.4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+bouquin-0.1.4.dist-info/METADATA,sha256=mJ_ZtOmlBZjkwq4ecGlCmzU3JVOBp_CwXoPscm37Tag,2468
+bouquin-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+bouquin-0.1.4.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
+bouquin-0.1.4.dist-info/RECORD,,

bouquin-0.1.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-bouquin/__init__.py,sha256=-bBNFYOq80A2Egtpo5V5zWJtYOxQfRZFQ_feve5lkFU,23
-bouquin/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-bouquin/db.py,sha256=LlKf_AzaJpzgN3cjxUshsHLybaIATgfQF1g9G92yYEw,3641
-bouquin/editor.py,sha256=HY5ASmSTiwb_pQzEdqyMBhKFOojw1bppuCk4FacE660,3540
-bouquin/key_prompt.py,sha256=RNrW0bN4xnwDGeBlgbmFaBSs_2iQyYrBYpKOQhe4E0c,1092
-bouquin/main.py,sha256=u7Wm5-9LRZDKkzKkK0W6P4oTtDorrrmtwIJWmQCqsRs,351
-bouquin/main_window.py,sha256=LOu80m5r6bg-tjY1R-Ol5H4bLUCVJbOR6nN2ykN7Q1M,10363
-bouquin/search.py,sha256=uTHkxsKrcWqVpXEbOMqCkqrAfVsQvIvgvDV6YNH06lA,6516
-bouquin/settings.py,sha256=bJYQXbTqX_r_DfOKuGnah6IVZLiNwZAuBuz2OgdhA_E,670
-bouquin/settings_dialog.py,sha256=HV7IERazYBjvMXyVkm9FmZqu3gVHlceNrfFaW_fQJHE,3150
-bouquin/toolbar.py,sha256=jPsix5f8VErO-P_cjRo_ZWHPW7KGGAAlHbC5S-2uStg,3050
-bouquin-0.1.2.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-bouquin-0.1.2.dist-info/METADATA,sha256=XLFFF4yUWZVjEVAliPz4XdP_qP1yUkhtr7CBGYCgSy0,2230
-bouquin-0.1.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-bouquin-0.1.2.dist-info/entry_points.txt,sha256=d2C5Mc85suj1vWg_mmcfFuEBAYEkdwhZquusme5EWuQ,49
-bouquin-0.1.2.dist-info/RECORD,,