bouquin 0.2.1.7__tar.gz → 0.3__tar.gz

{bouquin-0.2.1.7 → bouquin-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.2.1.7
+Version: 0.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
@@ -49,6 +49,7 @@ There is deliberately no network connectivity or syncing intended.
  * Tabs are supported - right-click on a date from the calendar to open it in a new tab.
  * Images are supported
  * Search all pages, or find text on page (Ctrl+F)
+ * Add tags to pages, find pages by tag in the Tag Browser, and customise tag names and colours
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
@@ -57,7 +58,8 @@ There is deliberately no network connectivity or syncing intended.
  * 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
+ * It is possible to automatically move unchecked checkboxes from yesterday to today, on startup
+ * English, French and Italian locales provided
 
 
 ## How to install

{bouquin-0.2.1.7 → bouquin-0.3}/README.md

@@ -29,6 +29,7 @@ There is deliberately no network connectivity or syncing intended.
  * Tabs are supported - right-click on a date from the calendar to open it in a new tab.
  * Images are supported
  * Search all pages, or find text on page (Ctrl+F)
+ * Add tags to pages, find pages by tag in the Tag Browser, and customise tag names and colours
  * Automatic periodic saving (or explicitly save)
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
@@ -37,7 +38,8 @@ There is deliberately no network connectivity or syncing intended.
  * 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
+ * It is possible to automatically move unchecked checkboxes from yesterday to today, on startup
+ * English, French and Italian locales provided
 
 
 ## How to install

{bouquin-0.2.1.7 → bouquin-0.3}/bouquin/db.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import csv
+import hashlib
 import html
 import json
 
@@ -9,7 +10,34 @@ from pathlib import Path
 from sqlcipher3 import dbapi2 as sqlite
 from typing import List, Sequence, Tuple
 
+
+from . import strings
+
 Entry = Tuple[str, str]
+TagRow = Tuple[int, str, str]
+
+_TAG_COLORS = [
+    "#FFB3BA",  # soft red
+    "#FFDFBA",  # soft orange
+    "#FFFFBA",  # soft yellow
+    "#BAFFC9",  # soft green
+    "#BAE1FF",  # soft blue
+    "#E0BAFF",  # soft purple
+    "#FFC4B3",  # soft coral
+    "#FFD8B1",  # soft peach
+    "#FFF1BA",  # soft light yellow
+    "#E9FFBA",  # soft lime
+    "#CFFFE5",  # soft mint
+    "#BAFFF5",  # soft aqua
+    "#BAF0FF",  # soft cyan
+    "#C7E9FF",  # soft sky blue
+    "#C7CEFF",  # soft periwinkle
+    "#F0BAFF",  # soft lavender pink
+    "#FFBAF2",  # soft magenta
+    "#FFD1F0",  # soft pink
+    "#EBD5C7",  # soft beige
+    "#EAEAEA",  # soft gray
+]
 
 
 @dataclass
@@ -19,6 +47,7 @@ class DBConfig:
     idle_minutes: int = 15  # 0 = never lock
     theme: str = "system"
     move_todos: bool = False
+    locale: str = "en"
 
 
 class DBManager:
@@ -62,8 +91,12 @@ class DBManager:
         # Not OK: rows of problems returned
         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)")
+            strings._("db_sqlcipher_integrity_check_failed")
+            + (
+                f": {details}"
+                if details
+                else f" ({len(rows)} {strings._('db_issues_reported')})"
+            )
         )
 
     def _ensure_schema(self) -> None:
@@ -75,7 +108,6 @@ class DBManager:
         # Always keep FKs on
         cur.execute("PRAGMA foreign_keys = ON;")
 
-        # Create new versioned schema if missing (< 0.1.5)
         cur.executescript(
             """
             CREATE TABLE IF NOT EXISTS pages (
@@ -96,6 +128,24 @@ class DBManager:
 
             CREATE UNIQUE INDEX IF NOT EXISTS ux_versions_date_ver ON versions(date, version_no);
             CREATE INDEX IF NOT EXISTS ix_versions_date_created ON versions(date, created_at);
+
+            CREATE TABLE IF NOT EXISTS tags (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL UNIQUE,
+                color TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS ix_tags_name ON tags(name);
+
+            CREATE TABLE IF NOT EXISTS page_tags (
+                page_date TEXT NOT NULL,               -- FK to pages.date
+                tag_id INTEGER NOT NULL,               -- FK to tags.id
+                PRIMARY KEY (page_date, tag_id),
+                FOREIGN KEY(page_date) REFERENCES pages(date) ON DELETE CASCADE,
+                FOREIGN KEY(tag_id) REFERENCES tags(id) ON DELETE CASCADE
+            );
+
+            CREATE INDEX IF NOT EXISTS ix_page_tags_tag_id ON page_tags(tag_id);
             """
         )
         self.conn.commit()
@@ -115,7 +165,7 @@ class DBManager:
         self.conn = None
         self.cfg.key = new_key
         if not self.connect():
-            raise sqlite.Error("Re-open failed after rekey")
+            raise sqlite.Error(strings._("db_reopen_failed_after_rekey"))
 
     def get_entry(self, date_iso: str) -> str:
         """
@@ -135,22 +185,31 @@ class DBManager:
 
     def search_entries(self, text: str) -> list[str]:
         """
-        Search for entries by term. This only works against the latest
-        version of the page.
+        Search for entries by term or tag name.
+        This only works against the latest version of the page.
         """
         cur = self.conn.cursor()
-        pattern = f"%{text}%"
+        q = text.strip()
+        pattern = f"%{q.lower()}%"
+
         rows = cur.execute(
             """
-            SELECT p.date, v.content
+            SELECT DISTINCT p.date, v.content
             FROM pages AS p
             JOIN versions AS v
               ON v.id = p.current_version_id
+            LEFT JOIN page_tags pt
+              ON pt.page_date = p.date
+            LEFT JOIN tags t
+                  ON t.id = pt.tag_id
             WHERE TRIM(v.content) <> ''
-              AND v.content LIKE LOWER(?) ESCAPE '\\'
+              AND (
+                LOWER(v.content) LIKE ?
+                 OR LOWER(COALESCE(t.name, '')) LIKE ?
+              )
             ORDER BY p.date DESC;
             """,
-            (pattern,),
+            (pattern, pattern),
         ).fetchall()
         return [(r[0], r[1]) for r in rows]
 
@@ -251,7 +310,9 @@ class DBManager:
             "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")
+            raise ValueError(
+                strings._("db_version_id_does_not_belong_to_the_given_date")
+            )
 
         with self.conn:
             cur.execute(
@@ -375,7 +436,185 @@ class DBManager:
             cur = self.conn.cursor()
             cur.execute("VACUUM")
         except Exception as e:
-            print(f"Error: {e}")
+            print(f"{strings._('error')}: {e}")
+
+    # -------- Tags: helpers -------------------------------------------
+
+    def _default_tag_colour(self, name: str) -> str:
+        """
+        Deterministically pick a colour for a tag name from a small palette.
+        """
+        if not name:
+            return "#CCCCCC"
+        h = int(hashlib.sha1(name.encode("utf-8")).hexdigest()[:8], 16)
+        return _TAG_COLORS[h % len(_TAG_COLORS)]
+
+    # -------- Tags: per-page -------------------------------------------
+
+    def get_tags_for_page(self, date_iso: str) -> list[TagRow]:
+        """
+        Return (id, name, color) for all tags attached to this page/date.
+        """
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            """
+            SELECT t.id, t.name, t.color
+            FROM page_tags pt
+            JOIN tags t ON t.id = pt.tag_id
+            WHERE pt.page_date = ?
+            ORDER BY LOWER(t.name);
+            """,
+            (date_iso,),
+        ).fetchall()
+        return [(r[0], r[1], r[2]) for r in rows]
+
+    def set_tags_for_page(self, date_iso: str, tag_names: Sequence[str]) -> None:
+        """
+        Replace the tag set for a page with the given names.
+        Creates new tags as needed (with auto colours).
+        Tags are case-insensitive - reuses existing tag if found with different case.
+        """
+        # Normalise + dedupe (case-insensitive)
+        clean_names = []
+        seen = set()
+        for name in tag_names:
+            name = name.strip()
+            if not name:
+                continue
+            if name.lower() in seen:
+                continue
+            seen.add(name.lower())
+            clean_names.append(name)
+
+        with self.conn:
+            cur = self.conn.cursor()
+
+            # Ensure the page row exists even if there's no content yet
+            cur.execute("INSERT OR IGNORE INTO pages(date) VALUES (?);", (date_iso,))
+
+            if not clean_names:
+                # Just clear all tags for this page
+                cur.execute("DELETE FROM page_tags WHERE page_date=?;", (date_iso,))
+                return
+
+            # For each tag name, check if it exists with different casing
+            # If so, reuse that existing tag; otherwise create new
+            final_tag_names = []
+            for name in clean_names:
+                # Look for existing tag (case-insensitive)
+                existing = cur.execute(
+                    "SELECT name FROM tags WHERE LOWER(name) = LOWER(?);", (name,)
+                ).fetchone()
+
+                if existing:
+                    # Use the existing tag's exact name
+                    final_tag_names.append(existing["name"])
+                else:
+                    # Create new tag with the provided casing
+                    cur.execute(
+                        """
+                        INSERT OR IGNORE INTO tags(name, color)
+                        VALUES (?, ?);
+                        """,
+                        (name, self._default_tag_colour(name)),
+                    )
+                    final_tag_names.append(name)
+
+            # Lookup ids for the final tag names
+            placeholders = ",".join("?" for _ in final_tag_names)
+            rows = cur.execute(
+                f"""
+                SELECT id, name
+                FROM tags
+                WHERE name IN ({placeholders});
+                """,
+                tuple(final_tag_names),
+            ).fetchall()
+            ids_by_name = {r["name"]: r["id"] for r in rows}
+
+            # Reset page_tags for this page
+            cur.execute("DELETE FROM page_tags WHERE page_date=?;", (date_iso,))
+            for name in final_tag_names:
+                tag_id = ids_by_name.get(name)
+                if tag_id is not None:
+                    cur.execute(
+                        """
+                        INSERT OR IGNORE INTO page_tags(page_date, tag_id)
+                        VALUES (?, ?);
+                        """,
+                        (date_iso, tag_id),
+                    )
+
+    # -------- Tags: global management ----------------------------------
+
+    def list_tags(self) -> list[TagRow]:
+        """
+        Return all tags in the database.
+        """
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            """
+            SELECT id, name, color
+            FROM tags
+            ORDER BY LOWER(name);
+            """
+        ).fetchall()
+        return [(r[0], r[1], r[2]) for r in rows]
+
+    def update_tag(self, tag_id: int, name: str, color: str) -> None:
+        """
+        Update a tag's name and colour.
+        """
+        name = name.strip()
+        color = color.strip() or "#CCCCCC"
+
+        try:
+            with self.conn:
+                cur = self.conn.cursor()
+                cur.execute(
+                    """
+                    UPDATE tags
+                    SET name = ?, color = ?
+                    WHERE id = ?;
+                    """,
+                    (name, color, tag_id),
+                )
+        except sqlite.IntegrityError as e:
+            if "UNIQUE constraint failed: tags.name" in str(e):
+                raise sqlite.IntegrityError(
+                    strings._("tag_already_exists_with_that_name")
+                ) from e
+
+    def delete_tag(self, tag_id: int) -> None:
+        """
+        Delete a tag entirely (removes it from all pages).
+        """
+        with self.conn:
+            cur = self.conn.cursor()
+            cur.execute("DELETE FROM page_tags WHERE tag_id=?;", (tag_id,))
+            cur.execute("DELETE FROM tags WHERE id=?;", (tag_id,))
+
+    def get_pages_for_tag(self, tag_name: str) -> list[Entry]:
+        """
+        Return (date, content) for pages that have the given tag.
+        """
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            """
+            SELECT p.date, v.content
+            FROM pages AS p
+            JOIN versions AS v
+              ON v.id = p.current_version_id
+            JOIN page_tags pt
+              ON pt.page_date = p.date
+            JOIN tags t
+              ON t.id = pt.tag_id
+            WHERE LOWER(t.name) = LOWER(?)
+            ORDER BY p.date DESC;
+            """,
+            (tag_name,),
+        ).fetchall()
+        return [(r[0], r[1]) for r in rows]
 
     def close(self) -> None:
         if self.conn is not None:

{bouquin-0.2.1.7 → bouquin-0.3}/bouquin/find_bar.py

@@ -17,6 +17,8 @@ from PySide6.QtWidgets import (
     QTextEdit,
 )
 
+from . import strings
+
 
 class FindBar(QWidget):
     """Widget for finding text in the Editor"""
@@ -41,17 +43,17 @@ class FindBar(QWidget):
         layout = QHBoxLayout(self)
         layout.setContentsMargins(6, 0, 6, 0)
 
-        layout.addWidget(QLabel("Find:"))
+        layout.addWidget(QLabel(strings._("find")))
 
         self.edit = QLineEdit(self)
-        self.edit.setPlaceholderText("Type to search")
+        self.edit.setPlaceholderText(strings._("find_bar_type_to_search"))
         layout.addWidget(self.edit)
 
-        self.case = QCheckBox("Match case", self)
+        self.case = QCheckBox(strings._("find_bar_match_case"), self)
         layout.addWidget(self.case)
 
-        self.prevBtn = QPushButton("Prev", self)
-        self.nextBtn = QPushButton("Next", self)
+        self.prevBtn = QPushButton(strings._("previous"), self)
+        self.nextBtn = QPushButton(strings._("next"), self)
         self.closeBtn = QPushButton("✕", self)
         self.closeBtn.setFlat(True)
         layout.addWidget(self.prevBtn)
@@ -120,8 +122,6 @@ class FindBar(QWidget):
         return flags
 
     def find_next(self):
-        if not self.editor:
-            return
         txt = self.edit.text()
         if not txt:
             return
@@ -147,8 +147,6 @@ class FindBar(QWidget):
         self._update_highlight()
 
     def find_prev(self):
-        if not self.editor:
-            return
         txt = self.edit.text()
         if not txt:
             return

bouquin-0.3/bouquin/flow_layout.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from PySide6.QtCore import QPoint, QRect, QSize, Qt
+from PySide6.QtWidgets import QLayout
+
+
+class FlowLayout(QLayout):
+    def __init__(
+        self, parent=None, margin: int = 0, hspacing: int = 4, vspacing: int = 4
+    ):
+        super().__init__(parent)
+        self._items = []
+        self._hspace = hspacing
+        self._vspace = vspacing
+        self.setContentsMargins(margin, margin, margin, margin)
+
+    def addItem(self, item):
+        self._items.append(item)
+
+    def itemAt(self, index):
+        if 0 <= index < len(self._items):
+            return self._items[index]
+        return None
+
+    def takeAt(self, index):
+        if 0 <= index < len(self._items):
+            return self._items.pop(index)
+        return None
+
+    def count(self):
+        return len(self._items)
+
+    def expandingDirections(self):
+        return Qt.Orientations(Qt.Orientation(0))
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width: int) -> int:
+        return self._do_layout(QRect(0, 0, width, 0), test_only=True)
+
+    def setGeometry(self, rect: QRect):
+        super().setGeometry(rect)
+        self._do_layout(rect, test_only=False)
+
+    def sizeHint(self) -> QSize:
+        return self.minimumSize()
+
+    def minimumSize(self) -> QSize:
+        size = QSize()
+        for item in self._items:
+            size = size.expandedTo(item.minimumSize())
+        left, top, right, bottom = self.getContentsMargins()
+        size += QSize(left + right, top + bottom)
+        return size
+
+    def _do_layout(self, rect: QRect, test_only: bool) -> int:
+        x = rect.x()
+        y = rect.y()
+        line_height = 0
+
+        left, top, right, bottom = self.getContentsMargins()
+        effective_rect = rect.adjusted(+left, +top, -right, -bottom)
+        x = effective_rect.x()
+        y = effective_rect.y()
+        max_right = effective_rect.right()
+
+        for item in self._items:
+            wid = item.widget()
+            if wid is None or not wid.isVisible():
+                continue
+            space_x = self._hspace
+            space_y = self._vspace
+            next_x = x + item.sizeHint().width() + space_x
+            if next_x - space_x > max_right and line_height > 0:
+                # Wrap
+                x = effective_rect.x()
+                y = y + line_height + space_y
+                next_x = x + item.sizeHint().width() + space_x
+                line_height = 0
+
+            if not test_only:
+                item.setGeometry(QRect(QPoint(x, y), item.sizeHint()))
+
+            x = next_x
+            line_height = max(line_height, item.sizeHint().height())
+
+        return y + line_height - rect.y() + bottom

{bouquin-0.2.1.7 → bouquin-0.3}/bouquin/history_dialog.py

@@ -15,6 +15,8 @@ from PySide6.QtWidgets import (
     QTabWidget,
 )
 
+from . import strings
+
 
 def _markdown_to_text(s: str) -> str:
     """Convert markdown to plain text for diff comparison."""
@@ -43,7 +45,9 @@ def _colored_unified_diff_html(old_md: str, new_md: str) -> str:
     """Return HTML with colored unified diff (+ green, - red, context gray)."""
     a = _markdown_to_text(old_md).splitlines()
     b = _markdown_to_text(new_md).splitlines()
-    ud = difflib.unified_diff(a, b, fromfile="current", tofile="selected", lineterm="")
+    ud = difflib.unified_diff(
+        a, b, fromfile=strings._("current"), tofile=strings._("selected"), lineterm=""
+    )
     lines = []
     for line in ud:
         if line.startswith("+") and not line.startswith("+++"):
@@ -67,7 +71,7 @@ class HistoryDialog(QDialog):
 
     def __init__(self, db, date_iso: str, parent=None):
         super().__init__(parent)
-        self.setWindowTitle(f"History — {date_iso}")
+        self.setWindowTitle(f"{strings._('history')} — {date_iso}")
         self._db = db
         self._date = date_iso
         self._versions = []  # list[dict] from DB
@@ -88,8 +92,8 @@ class HistoryDialog(QDialog):
         self.preview.setOpenExternalLinks(True)
         self.diff = QTextBrowser()
         self.diff.setOpenExternalLinks(False)
-        self.tabs.addTab(self.preview, "Preview")
-        self.tabs.addTab(self.diff, "Diff")
+        self.tabs.addTab(self.preview, strings._("history_dialog_preview"))
+        self.tabs.addTab(self.diff, strings._("history_dialog_diff"))
         self.tabs.setMinimumSize(500, 650)
         top.addWidget(self.tabs, 2)
 
@@ -98,9 +102,9 @@ class HistoryDialog(QDialog):
         # Buttons
         row = QHBoxLayout()
         row.addStretch(1)
-        self.btn_revert = QPushButton("Revert to Selected")
+        self.btn_revert = QPushButton(strings._("history_dialog_revert_to_selected"))
         self.btn_revert.clicked.connect(self._revert)
-        self.btn_close = QPushButton("Close")
+        self.btn_close = QPushButton(strings._("close"))
         self.btn_close.clicked.connect(self.reject)
         row.addWidget(self.btn_revert)
         row.addWidget(self.btn_close)
@@ -126,7 +130,7 @@ class HistoryDialog(QDialog):
             if v.get("note"):
                 label += f"  ·  {v['note']}"
             if v["is_current"]:
-                label += "  **(current)**"
+                label += "  **(" + strings._("current") + ")**"
             it = QListWidgetItem(label)
             it.setData(Qt.UserRole, v["id"])
             self.list.addItem(it)
@@ -159,8 +163,6 @@ class HistoryDialog(QDialog):
     @Slot()
     def _revert(self):
         item = self.list.currentItem()
-        if not item:
-            return
         sel_id = item.data(Qt.UserRole)
         if sel_id == self._current_id:
             return
@@ -168,6 +170,8 @@ class HistoryDialog(QDialog):
         try:
             self._db.revert_to_version(self._date, version_id=sel_id)
         except Exception as e:
-            QMessageBox.critical(self, "Revert failed", str(e))
+            QMessageBox.critical(
+                self, strings._("history_dialog_revert_failed"), str(e)
+            )
             return
         self.accept()

{bouquin-0.2.1.7 → bouquin-0.3}/bouquin/key_prompt.py

@@ -9,13 +9,15 @@ from PySide6.QtWidgets import (
     QDialogButtonBox,
 )
 
+from . import strings
+
 
 class KeyPrompt(QDialog):
     def __init__(
         self,
         parent=None,
-        title: str = "Enter key",
-        message: str = "Enter key",
+        title: str = strings._("key_prompt_enter_key"),
+        message: str = strings._("key_prompt_enter_key"),
     ):
         """
         Prompt the user for the key required to decrypt the database.
@@ -30,7 +32,7 @@ class KeyPrompt(QDialog):
         self.edit = QLineEdit()
         self.edit.setEchoMode(QLineEdit.Password)
         v.addWidget(self.edit)
-        toggle = QPushButton("Show")
+        toggle = QPushButton(strings._("show"))
         toggle.setCheckable(True)
         toggle.toggled.connect(
             lambda c: self.edit.setEchoMode(