bouquin 0.1.1__tar.gz → 0.1.3__tar.gz

{bouquin-0.1.1 → bouquin-0.1.3}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.1.1
+Version: 0.1.3
 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
 Author: Miguel Jacq
 Author-email: mig@mig5.net
@@ -14,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: pyside6 (>=6.8.1,<7.0.0)
 Requires-Dist: sqlcipher3-wheels (>=0.5.5.post0,<0.6.0)
+Project-URL: Repository, https://git.mig5.net/mig5/bouquin
 Description-Content-Type: text/markdown
 
 # Bouquin
@@ -27,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.
 
@@ -37,23 +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
- * Basic markdown
+ * Text is HTML with basic styling
+ * Search
  * Automatic periodic saving (or explicitly save)
- * Navigating from one day to the next automatically saves
- * Basic keyboard shortcuts
  * Transparent integrity checking of the database when it opens
-
-
-## Yet to do
-
- * Search
- * Taxonomy/tagging
- * Export to other formats (plaintext, json, sql etc)
+ * Rekey the database (change the password)
+ * 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
@@ -65,7 +65,7 @@ There is deliberately no network connectivity or syncing intended.
 
  * Download the whl and run it
 
-### From PyPi
+### From PyPi/pip
 
  * `pip install bouquin`
 

{bouquin-0.1.1 → bouquin-0.1.3}/README.md

@@ -9,7 +9,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.
 
@@ -19,23 +19,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
- * Basic markdown
+ * Text is HTML with basic styling
+ * Search
  * Automatic periodic saving (or explicitly save)
- * Navigating from one day to the next automatically saves
- * Basic keyboard shortcuts
  * Transparent integrity checking of the database when it opens
-
-
-## Yet to do
-
- * Search
- * Taxonomy/tagging
- * Export to other formats (plaintext, json, sql etc)
+ * Rekey the database (change the password)
+ * 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
@@ -47,7 +45,7 @@ There is deliberately no network connectivity or syncing intended.
 
  * Download the whl and run it
 
-### From PyPi
+### From PyPi/pip
 
  * `pip install bouquin`
 

bouquin-0.1.3/bouquin/db.py

@@ -0,0 +1,226 @@
+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
+
+
+class DBManager:
+    def __init__(self, cfg: DBConfig):
+        self.cfg = cfg
+        self.conn: sqlite.Connection | None = None
+
+    def connect(self) -> bool:
+        # 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 journal_mode = WAL;")
+        self.conn.commit()
+        try:
+            self._integrity_ok()
+        except Exception:
+            self.conn.close()
+            self.conn = None
+            return False
+        self._ensure_schema()
+        return True
+
+    def _integrity_ok(self) -> bool:
+        cur = self.conn.cursor()
+        cur.execute("PRAGMA cipher_integrity_check;")
+        rows = cur.fetchall()
+
+        # OK
+        if not rows:
+            return
+
+        # Not OK
+        details = "; ".join(str(r[0]) for r in rows if r and r[0] is not None)
+        raise sqlite.IntegrityError(
+            "SQLCipher integrity check failed"
+            + (f": {details}" if details else f" ({len(rows)} issue(s) reported)")
+        )
+
+    def _ensure_schema(self) -> None:
+        cur = self.conn.cursor()
+        cur.execute(
+            """
+            CREATE TABLE IF NOT EXISTS entries (
+                date TEXT PRIMARY KEY, -- ISO yyyy-MM-dd
+                content TEXT NOT NULL
+            );
+            """
+        )
+        cur.execute("PRAGMA user_version = 1;")
+        self.conn.commit()
+
+    def rekey(self, new_key: str) -> None:
+        """
+        Change the SQLCipher passphrase in-place, then reopen the connection
+        with the new key to verify.
+        """
+        if self.conn is None:
+            raise RuntimeError("Database is not connected")
+        cur = self.conn.cursor()
+        # Change the encryption key of the currently open database
+        cur.execute(f"PRAGMA rekey = '{new_key}';")
+        self.conn.commit()
+
+        # Close and reopen with the new key to verify and restore PRAGMAs
+        self.conn.close()
+        self.conn = None
+        self.cfg.key = new_key
+        if not self.connect():
+            raise sqlite.Error("Re-open failed after rekey")
+
+    def get_entry(self, date_iso: str) -> str:
+        cur = self.conn.cursor()
+        cur.execute("SELECT content FROM entries WHERE date = ?;", (date_iso,))
+        row = cur.fetchone()
+        return row[0] if row else ""
+
+    def upsert_entry(self, date_iso: str, content: str) -> None:
+        cur = self.conn.cursor()
+        cur.execute(
+            """
+            INSERT INTO entries(date, content) VALUES(?, ?)
+            ON CONFLICT(date) DO UPDATE SET content = excluded.content;
+            """,
+            (date_iso, content),
+        )
+        self.conn.commit()
+
+    def search_entries(self, text: str) -> list[str]:
+        cur = self.conn.cursor()
+        pattern = f"%{text}%"
+        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()
+            self.conn = None

bouquin-0.1.3/bouquin/editor.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from PySide6.QtGui import (
+    QColor,
+    QDesktopServices,
+    QFont,
+    QFontDatabase,
+    QTextCharFormat,
+    QTextCursor,
+    QTextListFormat,
+    QTextBlockFormat,
+)
+from PySide6.QtCore import Qt, QUrl, Signal, Slot, QRegularExpression
+from PySide6.QtWidgets import QTextEdit
+
+
+class Editor(QTextEdit):
+    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.
+        """
+        cursor = self.textCursor()
+        if not cursor.hasSelection():
+            cursor.select(cursor.SelectionType.WordUnderCursor)
+        cursor.mergeCharFormat(fmt)
+        self.mergeCurrentCharFormat(fmt)
+
+    @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)
+
+    @Slot()
+    def apply_italic(self):
+        cur = self.currentCharFormat()
+        fmt = QTextCharFormat()
+        fmt.setFontItalic(not cur.fontItalic())
+        self.merge_on_sel(fmt)
+
+    @Slot()
+    def apply_underline(self):
+        cur = self.currentCharFormat()
+        fmt = QTextCharFormat()
+        fmt.setFontUnderline(not cur.fontUnderline())
+        self.merge_on_sel(fmt)
+
+    @Slot()
+    def apply_strikethrough(self):
+        cur = self.currentCharFormat()
+        fmt = QTextCharFormat()
+        fmt.setFontStrikeOut(not cur.fontStrikeOut())
+        self.merge_on_sel(fmt)
+
+    @Slot()
+    def apply_code(self):
+        c = self.textCursor()
+        if not c.hasSelection():
+            c.select(c.SelectionType.BlockUnderCursor)
+
+        bf = QTextBlockFormat()
+        bf.setLeftMargin(12)
+        bf.setRightMargin(12)
+        bf.setTopMargin(6)
+        bf.setBottomMargin(6)
+        bf.setBackground(QColor(245, 245, 245))
+        bf.setNonBreakableLines(True)
+
+        cf = QTextCharFormat()
+        mono = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+        cf.setFont(mono)
+        cf.setFontFixedPitch(True)
+
+        # If the current block already looks like a code block, remove styling
+        cur_bf = c.blockFormat()
+        is_code = (
+            cur_bf.nonBreakableLines()
+            and cur_bf.background().color().rgb() == QColor(245, 245, 245).rgb()
+        )
+        if is_code:
+            # clear: margins/background/wrapping
+            bf = QTextBlockFormat()
+            cf = QTextCharFormat()
+
+        c.mergeBlockFormat(bf)
+        c.mergeBlockCharFormat(cf)
+
+    @Slot(int)
+    def apply_heading(self, size):
+        fmt = QTextCharFormat()
+        if size:
+            fmt.setFontWeight(QFont.Weight.Bold)
+            fmt.setFontPointSize(size)
+        else:
+            fmt.setFontWeight(QFont.Weight.Normal)
+            fmt.setFontPointSize(self.font().pointSizeF())
+        self.merge_on_sel(fmt)
+
+    def toggle_bullets(self):
+        c = self.textCursor()
+        lst = c.currentList()
+        if lst and lst.format().style() == QTextListFormat.Style.ListDisc:
+            lst.remove(c.block())
+            return
+        fmt = QTextListFormat()
+        fmt.setStyle(QTextListFormat.Style.ListDisc)
+        c.createList(fmt)
+
+    def toggle_numbers(self):
+        c = self.textCursor()
+        lst = c.currentList()
+        if lst and lst.format().style() == QTextListFormat.Style.ListDecimal:
+            lst.remove(c.block())
+            return
+        fmt = QTextListFormat()
+        fmt.setStyle(QTextListFormat.Style.ListDecimal)
+        c.createList(fmt)

{bouquin-0.1.1 → bouquin-0.1.3}/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-0.1.1 → bouquin-0.1.3}/bouquin/main.py

@@ -11,5 +11,6 @@ def main():
     app = QApplication(sys.argv)
     app.setApplicationName(APP_NAME)
     app.setOrganizationName(APP_ORG)
-    win = MainWindow(); win.show()
+    win = MainWindow()
+    win.show()
     sys.exit(app.exec())