bouquin 0.3__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.3
+Version: 0.3.1
 Summary: Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
 Home-page: https://git.mig5.net/mig5/bouquin
 License: GPL-3.0-or-later
@@ -54,7 +54,7 @@ There is deliberately no network connectivity or syncing intended.
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
  * Rekey the database (change the password)
- * Export the database to json, txt, html, csv, markdown or .sql (for sqlite3)
+ * Export the database to json, html, csv, markdown or .sql (for sqlite3)
  * Backup the database to encrypted SQLCipher format (which can then be loaded back in to a Bouquin)
  * Dark and light themes
  * Automatically generate checkboxes when typing 'TODO'

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

@@ -34,7 +34,7 @@ There is deliberately no network connectivity or syncing intended.
  * Transparent integrity checking of the database when it opens
  * Automatic locking of the app after a period of inactivity (default 15 min)
  * Rekey the database (change the password)
- * Export the database to json, txt, html, csv, markdown or .sql (for sqlite3)
+ * Export the database to json, html, csv, markdown or .sql (for sqlite3)
  * Backup the database to encrypted SQLCipher format (which can then be loaded back in to a Bouquin)
  * Dark and light themes
  * Automatically generate checkboxes when typing 'TODO'

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

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 import csv
+import datetime as _dt
 import hashlib
 import html
 import json
+import re
 
 from dataclasses import dataclass
 from pathlib import Path
 from sqlcipher3 import dbapi2 as sqlite
-from typing import List, Sequence, Tuple
+from typing import List, Sequence, Tuple, Dict
 
 
 from . import strings
@@ -354,21 +356,6 @@ class DBManager:
             writer.writerow(["date", "content"])  # header
             writer.writerows(entries)
 
-    def export_txt(
-        self,
-        entries: Sequence[Entry],
-        file_path: str,
-        separator: str = "\n\n— — — — —\n\n",
-    ) -> None:
-        """
-        Strip the the latest version of the pages to a text file.
-        """
-        with open(file_path, "w", encoding="utf-8") as f:
-            for i, (d, c) in enumerate(entries):
-                f.write(f"{d}\n{c}\n")
-                if i < len(entries) - 1:
-                    f.write(separator)
-
     def export_html(
         self, entries: Sequence[Entry], file_path: str, title: str = "Bouquin export"
     ) -> None:
@@ -561,6 +548,30 @@ class DBManager:
         ).fetchall()
         return [(r[0], r[1], r[2]) for r in rows]
 
+    def add_tag(self, 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(
+                    """
+                    INSERT INTO tags
+                    (name, color)
+                    VALUES (?, ?);
+                    """,
+                    (name, color),
+                )
+        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 update_tag(self, tag_id: int, name: str, color: str) -> None:
         """
         Update a tag's name and colour.
@@ -616,6 +627,125 @@ class DBManager:
         ).fetchall()
         return [(r[0], r[1]) for r in rows]
 
+    # ---------- helpers for word counting ----------
+    def _strip_markdown(self, text: str) -> str:
+        """
+        Cheap markdown-ish stripper for word counting.
+        We only need approximate numbers.
+        """
+        if not text:
+            return ""
+
+        # Remove fenced code blocks
+        text = re.sub(r"```.*?```", " ", text, flags=re.DOTALL)
+        # Remove inline code
+        text = re.sub(r"`[^`]+`", " ", text)
+        # [text](url) → text
+        text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
+        # Remove emphasis markers, headings, etc.
+        text = re.sub(r"[#*_>]+", " ", text)
+        # Strip simple HTML tags
+        text = re.sub(r"<[^>]+>", " ", text)
+
+        return text
+
+    def _count_words(self, text: str) -> int:
+        text = self._strip_markdown(text)
+        words = re.findall(r"\b\w+\b", text, flags=re.UNICODE)
+        return len(words)
+
+    def gather_stats(self):
+        """Compute all the numbers the Statistics dialog needs in one place."""
+
+        # 1) pages with content (current version only)
+        try:
+            pages_with_content_list = self.dates_with_content()
+        except Exception:
+            pages_with_content_list = []
+        pages_with_content = len(pages_with_content_list)
+
+        cur = self.conn.cursor()
+
+        # 2 & 3) total revisions + page with most revisions + per-date counts
+        total_revisions = 0
+        page_most_revisions = None
+        page_most_revisions_count = 0
+        revisions_by_date: Dict[_dt.date, int] = {}
+
+        rows = cur.execute(
+            """
+            SELECT date, COUNT(*) AS c
+            FROM versions
+            GROUP BY date
+            ORDER BY date;
+            """
+        ).fetchall()
+
+        for r in rows:
+            date_iso = r["date"]
+            c = int(r["c"])
+            total_revisions += c
+
+            if c > page_most_revisions_count:
+                page_most_revisions_count = c
+                page_most_revisions = date_iso
+
+            try:
+                d = _dt.date.fromisoformat(date_iso)
+                revisions_by_date[d] = c
+            except ValueError:
+                # Ignore malformed dates
+                pass
+
+        # 4) total words + per-date words (current version only)
+        entries = self.get_all_entries()
+        total_words = 0
+        words_by_date: Dict[_dt.date, int] = {}
+
+        for date_iso, content in entries:
+            wc = self._count_words(content or "")
+            total_words += wc
+            try:
+                d = _dt.date.fromisoformat(date_iso)
+                words_by_date[d] = wc
+            except ValueError:
+                pass
+
+        # tags + page with most tags
+
+        rows = cur.execute("SELECT COUNT(*) AS total_unique FROM tags;").fetchall()
+        unique_tags = int(rows[0]["total_unique"]) if rows else 0
+
+        rows = cur.execute(
+            """
+            SELECT page_date, COUNT(*) AS c
+            FROM page_tags
+            GROUP BY page_date
+            ORDER BY c DESC, page_date ASC
+            LIMIT 1;
+            """
+        ).fetchall()
+
+        if rows:
+            page_most_tags = rows[0]["page_date"]
+            page_most_tags_count = int(rows[0]["c"])
+        else:
+            page_most_tags = None
+            page_most_tags_count = 0
+
+        return (
+            pages_with_content,
+            total_revisions,
+            page_most_revisions,
+            page_most_revisions_count,
+            words_by_date,
+            total_words,
+            unique_tags,
+            page_most_tags,
+            page_most_tags_count,
+            revisions_by_date,
+        )
+
     def close(self) -> None:
         if self.conn is not None:
             self.conn.close()

{bouquin-0.3 → bouquin-0.3.1}/bouquin/locales/en.json

@@ -114,6 +114,7 @@
     "tags": "Tags",
     "tag": "Tag",
     "manage_tags": "Manage tags",
+    "main_window_manage_tags_accessible_flag": "Manage &Tags",
     "add_tag_placeholder": "Add a tag and press Enter",
     "tag_browser_title": "Tag Browser",
     "tag_browser_instructions": "Click a tag to expand and see all pages with that tag. Click a date to open it. Select a tag to edit its name, change its color, or delete it globally.",
@@ -127,10 +128,24 @@
     "add": "Add",
     "remove": "Remove",
     "ok": "OK",
+    "add_a_tag": "Add a tag",
     "edit_tag_name": "Edit tag name",
     "new_tag_name": "New tag name:",
     "change_color": "Change colour",
     "delete_tag": "Delete tag",
     "delete_tag_confirm": "Are you sure you want to delete the tag '{name}'? This will remove it from all pages.",
-    "tag_already_exists_with_that_name": "A tag already exists with that name"
+    "tag_already_exists_with_that_name": "A tag already exists with that name",
+    "statistics": "Statistics",
+    "main_window_statistics_accessible_flag": "Stat&istics",
+    "stats_pages_with_content": "Pages with content (current version)",
+    "stats_total_revisions": "Total revisions",
+    "stats_page_most_revisions": "Page with most revisions",
+    "stats_total_words": "Total words (current versions)",
+    "stats_unique_tags": "Unique tags",
+    "stats_page_most_tags": "Page with most tags",
+    "stats_activity_heatmap": "Activity heatmap",
+    "stats_heatmap_metric": "Colour by",
+    "stats_metric_words": "Words",
+    "stats_metric_revisions": "Revisions",
+    "stats_no_data": "No statistics available yet."
 }

{bouquin-0.3 → bouquin-0.3.1}/bouquin/locales/fr.json

@@ -127,6 +127,7 @@
     "add": "Ajouter",
     "remove": "Supprimer",
     "ok": "OK",
+    "add_a_tag": "Ajouter une étiquette",
     "edit_tag_name": "Modifier le nom de l'étiquette",
     "new_tag_name": "Nouveau nom de l'étiquette :",
     "change_color": "Changer la couleur",

{bouquin-0.3 → bouquin-0.3.1}/bouquin/locales/it.json

@@ -126,6 +126,7 @@
     "add": "Aggiungi",
     "remove": "Rimuovi",
     "ok": "OK",
+    "add_a_tag": "Aggiungi un tag",
     "edit_tag_name": "Modifica nome tag",
     "new_tag_name": "Nuovo nome tag:",
     "change_color": "Cambia colore",

{bouquin-0.3 → bouquin-0.3.1}/bouquin/main_window.py

@@ -55,6 +55,7 @@ from .save_dialog import SaveDialog
 from .search import Search
 from .settings import APP_ORG, APP_NAME, load_db_config, save_db_config
 from .settings_dialog import SettingsDialog
+from .statistics_dialog import StatisticsDialog
 from . import strings
 from .tags_widget import PageTagsWidget
 from .toolbar import ToolBar
@@ -209,10 +210,14 @@ class MainWindow(QMainWindow):
         act_backup.setShortcut("Ctrl+Shift+B")
         act_backup.triggered.connect(self._backup)
         file_menu.addAction(act_backup)
-        act_tags = QAction("&" + strings._("manage_tags"), self)
+        act_tags = QAction(strings._("main_window_manage_tags_accessible_flag"), self)
         act_tags.setShortcut("Ctrl+T")
         act_tags.triggered.connect(self.tags._open_manager)
         file_menu.addAction(act_tags)
+        act_stats = QAction(strings._("main_window_statistics_accessible_flag"), self)
+        act_stats.setShortcut("Shift+Ctrl+S")
+        act_stats.triggered.connect(self._open_statistics)
+        file_menu.addAction(act_stats)
         file_menu.addSeparator()
         act_quit = QAction("&" + strings._("quit"), self)
         act_quit.setShortcut("Ctrl+Q")
@@ -435,6 +440,7 @@ class MainWindow(QMainWindow):
         return self._create_new_tab(date)
 
     def _create_new_tab(self, date: QDate | None = None) -> MarkdownEditor:
+        """Create a new editor tab and return the editor instance."""
         if date is None:
             date = self.calendar.selectedDate()
 
@@ -444,7 +450,6 @@ class MainWindow(QMainWindow):
             self.tab_widget.setCurrentIndex(existing)
             return self.tab_widget.widget(existing)
 
-        """Create a new editor tab and return the editor instance."""
         editor = MarkdownEditor(self.themes)
 
         # Set up the editor's event connections
@@ -1124,6 +1129,15 @@ class MainWindow(QMainWindow):
             self._load_selected_date()
             self._refresh_calendar_marks()
 
+    # ------------ Statistics handler --------------- #
+
+    def _open_statistics(self):
+        if not getattr(self, "db", None) or self.db.conn is None:
+            return
+
+        dlg = StatisticsDialog(self.db, self)
+        dlg.exec()
+
     # ------------ Window positioning --------------- #
     def _restore_window_position(self):
         geom = self.settings.value("main/geometry", None)
@@ -1174,7 +1188,6 @@ class MainWindow(QMainWindow):
             return False
 
         filters = (
-            "Text (*.txt);;"
             "JSON (*.json);;"
             "CSV (*.csv);;"
             "HTML (*.html);;"
@@ -1190,22 +1203,19 @@ class MainWindow(QMainWindow):
             return  # user cancelled
 
         default_ext = {
-            "Text (*.txt)": ".txt",
             "JSON (*.json)": ".json",
             "CSV (*.csv)": ".csv",
             "HTML (*.html)": ".html",
             "Markdown (*.md)": ".md",
             "SQL (*.sql)": ".sql",
-        }.get(selected_filter, ".txt")
+        }.get(selected_filter, ".md")
 
         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"):
+            if selected_filter.startswith("JSON"):
                 self.db.export_json(entries, filename)
             elif selected_filter.startswith("CSV"):
                 self.db.export_csv(entries, filename)

{bouquin-0.3 → bouquin-0.3.1}/bouquin/markdown_editor.py

@@ -14,8 +14,9 @@ from PySide6.QtGui import (
     QTextFormat,
     QTextBlockFormat,
     QTextImageFormat,
+    QDesktopServices,
 )
-from PySide6.QtCore import Qt, QRect, QTimer
+from PySide6.QtCore import Qt, QRect, QTimer, QUrl
 from PySide6.QtWidgets import QTextEdit
 
 from .theme import ThemeManager
@@ -70,6 +71,11 @@ class MarkdownEditor(QTextEdit):
 
         # Enable mouse tracking for checkbox clicking
         self.viewport().setMouseTracking(True)
+        # Also mark links as mouse-accessible
+        flags = self.textInteractionFlags()
+        self.setTextInteractionFlags(
+            flags | Qt.TextInteractionFlag.LinksAccessibleByMouse
+        )
 
     def setDocument(self, doc):
         super().setDocument(doc)
@@ -400,6 +406,28 @@ class MarkdownEditor(QTextEdit):
 
         return (None, "")
 
+    def _url_at_pos(self, pos) -> str | None:
+        """
+        Return the URL under the given widget position, or None if there isn't one.
+        """
+        cursor = self.cursorForPosition(pos)
+        block = cursor.block()
+        text = block.text()
+        if not text:
+            return None
+
+        # Position of the cursor inside this block
+        pos_in_block = cursor.position() - block.position()
+
+        # Same pattern as in MarkdownHighlighter
+        url_pattern = re.compile(r"(https?://[^\s<>()]+)")
+        for m in url_pattern.finditer(text):
+            start, end = m.span(1)
+            if start <= pos_in_block < end:
+                return m.group(1)
+
+        return None
+
     def keyPressEvent(self, event):
         """Handle special key events for markdown editing."""
 
@@ -622,6 +650,37 @@ class MarkdownEditor(QTextEdit):
         # Default handling
         super().keyPressEvent(event)
 
+    def mouseMoveEvent(self, event):
+        # Change cursor when hovering a link
+        url = self._url_at_pos(event.pos())
+        if url:
+            self.viewport().setCursor(Qt.PointingHandCursor)
+        else:
+            self.viewport().setCursor(Qt.IBeamCursor)
+
+        super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        # Let QTextEdit handle caret/selection first
+        super().mouseReleaseEvent(event)
+
+        if event.button() != Qt.LeftButton:
+            return
+
+        # If the user dragged to select text, don't treat it as a click
+        if self.textCursor().hasSelection():
+            return
+
+        url_str = self._url_at_pos(event.pos())
+        if not url_str:
+            return
+
+        url = QUrl(url_str)
+        if not url.scheme():
+            url.setScheme("https")
+
+        QDesktopServices.openUrl(url)
+
     def mousePressEvent(self, event):
         """Toggle a checkbox only when the click lands on its icon."""
         if event.button() == Qt.LeftButton:

{bouquin-0.3 → bouquin-0.3.1}/bouquin/markdown_highlighter.py

@@ -91,6 +91,13 @@ class MarkdownHighlighter(QSyntaxHighlighter):
         self.h3_format.setFontPointSize(14.0)
         self.h3_format.setFontWeight(QFont.Weight.Bold)
 
+        # Hyperlinks
+        self.link_format = QTextCharFormat()
+        link_color = pal.color(QPalette.Link)
+        self.link_format.setForeground(link_color)
+        self.link_format.setFontUnderline(True)
+        self.link_format.setAnchor(True)
+
         # Markdown syntax (the markers themselves) - make invisible
         self.syntax_format = QTextCharFormat()
         # Make the markers invisible by setting font size to 0.1 points
@@ -243,3 +250,15 @@ class MarkdownHighlighter(QSyntaxHighlighter):
             self.setFormat(start, 1, self.syntax_format)
             self.setFormat(end - 1, 1, self.syntax_format)
             self.setFormat(content_start, content_end - content_start, self.code_format)
+
+        # Hyperlinks
+        url_pattern = re.compile(r"(https?://[^\s<>()]+)")
+        for m in url_pattern.finditer(text):
+            start, end = m.span(1)
+            url = m.group(1)
+
+            # Clone link format so we can attach a per-link href
+            fmt = QTextCharFormat(self.link_format)
+            fmt.setAnchorHref(url)
+            # Overlay link attributes on top of whatever formatting is already there
+            self._overlay_range(start, end - start, fmt)

bouquin-0.3.1/bouquin/statistics_dialog.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import datetime as _dt
+from typing import Dict
+
+from PySide6.QtCore import Qt, QSize
+from PySide6.QtGui import QColor, QPainter, QPen, QBrush
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QFormLayout,
+    QLabel,
+    QGroupBox,
+    QHBoxLayout,
+    QComboBox,
+    QScrollArea,
+    QWidget,
+    QSizePolicy,
+)
+
+from . import strings
+from .db import DBManager
+
+
+# ---------- Activity heatmap ----------
+
+
+class DateHeatmap(QWidget):
+    """
+    Small calendar heatmap for activity by date.
+
+    Data is a mapping: datetime.date -> integer value.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._data: Dict[_dt.date, int] = {}
+        self._start: _dt.date | None = None
+        self._end: _dt.date | None = None
+        self._max_value: int = 0
+
+        self._cell = 12
+        self._gap = 3
+        self._margin_left = 10
+        self._margin_top = 10
+        self._margin_bottom = 24
+        self._margin_right = 10
+
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+
+    def set_data(self, data: Dict[_dt.date, int]) -> None:
+        """Replace dataset and recompute layout."""
+        self._data = {k: int(v) for k, v in (data or {}).items() if v is not None}
+        if not self._data:
+            self._start = self._end = None
+            self._max_value = 0
+        else:
+            earliest = min(self._data.keys())
+            latest = max(self._data.keys())
+            self._start = earliest - _dt.timedelta(days=earliest.weekday())
+            self._end = latest
+            self._max_value = max(self._data.values()) if self._data else 0
+
+        self.updateGeometry()
+        self.update()
+
+    # QWidget overrides ---------------------------------------------------
+
+    def sizeHint(self) -> QSize:
+        if not self._start or not self._end:
+            height = (
+                self._margin_top + self._margin_bottom + 7 * (self._cell + self._gap)
+            )
+            # some default width
+            width = (
+                self._margin_left + self._margin_right + 20 * (self._cell + self._gap)
+            )
+            return QSize(width, height)
+
+        day_count = (self._end - self._start).days + 1
+        weeks = (day_count + 6) // 7  # ceil
+
+        width = (
+            self._margin_left
+            + self._margin_right
+            + weeks * (self._cell + self._gap)
+            + self._gap
+        )
+        height = (
+            self._margin_top
+            + self._margin_bottom
+            + 7 * (self._cell + self._gap)
+            + self._gap
+        )
+        return QSize(width, height)
+
+    def minimumSizeHint(self) -> QSize:
+        sz = self.sizeHint()
+        return QSize(min(300, sz.width()), sz.height())
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+
+        if not self._start or not self._end:
+            return
+
+        palette = self.palette()
+        bg_no_data = palette.base().color()
+        active = palette.highlight().color()
+
+        painter.setPen(QPen(Qt.NoPen))
+
+        day_count = (self._end - self._start).days + 1
+        weeks = (day_count + 6) // 7
+
+        for week in range(weeks):
+            for dow in range(7):
+                idx = week * 7 + dow
+                date = self._start + _dt.timedelta(days=idx)
+                if date > self._end:
+                    value = 0
+                else:
+                    value = self._data.get(date, 0)
+
+                x = self._margin_left + week * (self._cell + self._gap)
+                y = self._margin_top + dow * (self._cell + self._gap)
+
+                if value <= 0 or self._max_value <= 0:
+                    color = bg_no_data
+                else:
+                    ratio = max(0.1, min(1.0, value / float(self._max_value)))
+                    color = QColor(active)
+                    # Lighter for low values, darker for high values
+                    lighten = 150 - int(50 * ratio)  # 150 ≈ light, 100 ≈ original
+                    color = color.lighter(lighten)
+
+                painter.fillRect(
+                    x,
+                    y,
+                    self._cell,
+                    self._cell,
+                    QBrush(color),
+                )
+
+        painter.setPen(palette.text().color())
+        fm = painter.fontMetrics()
+
+        prev_month = None
+        for week in range(weeks):
+            date = self._start + _dt.timedelta(days=week * 7)
+            if date > self._end:
+                break
+
+            if prev_month == date.month:
+                continue
+            prev_month = date.month
+
+            label = date.strftime("%b")
+
+            x_center = (
+                self._margin_left + week * (self._cell + self._gap) + self._cell / 2
+            )
+            y = self._margin_top + 7 * (self._cell + self._gap) + fm.ascent()
+
+            text_width = fm.horizontalAdvance(label)
+            painter.drawText(
+                int(x_center - text_width / 2),
+                int(y),
+                label,
+            )
+
+        painter.end()
+
+
+# ---------- Statistics dialog itself ----------
+
+
+class StatisticsDialog(QDialog):
+    """
+    Shows aggregate statistics and the date heatmap with a metric switcher.
+    """
+
+    def __init__(self, db: DBManager, parent=None):
+        super().__init__(parent)
+        self._db = db
+
+        self.setWindowTitle(strings._("statistics"))
+
+        root = QVBoxLayout(self)
+
+        (
+            pages_with_content,
+            total_revisions,
+            page_most_revisions,
+            page_most_revisions_count,
+            words_by_date,
+            total_words,
+            unique_tags,
+            page_most_tags,
+            page_most_tags_count,
+            revisions_by_date,
+        ) = self._gather_stats()
+
+        # --- Numeric summary at the top ----------------------------------
+        form = QFormLayout()
+        root.addLayout(form)
+
+        form.addRow(
+            strings._("stats_pages_with_content"),
+            QLabel(str(pages_with_content)),
+        )
+        form.addRow(
+            strings._("stats_total_revisions"),
+            QLabel(str(total_revisions)),
+        )
+
+        if page_most_revisions:
+            form.addRow(
+                strings._("stats_page_most_revisions"),
+                QLabel(f"{page_most_revisions} ({page_most_revisions_count})"),
+            )
+        else:
+            form.addRow(strings._("stats_page_most_revisions"), QLabel("—"))
+
+        form.addRow(
+            strings._("stats_total_words"),
+            QLabel(str(total_words)),
+        )
+
+        # Unique tag names
+        form.addRow(
+            strings._("stats_unique_tags"),
+            QLabel(str(unique_tags)),
+        )
+
+        if page_most_tags:
+            form.addRow(
+                strings._("stats_page_most_tags"),
+                QLabel(f"{page_most_tags} ({page_most_tags_count})"),
+            )
+        else:
+            form.addRow(strings._("stats_page_most_tags"), QLabel("—"))
+
+        # --- Heatmap with switcher ---------------------------------------
+        if words_by_date or revisions_by_date:
+            group = QGroupBox(strings._("stats_activity_heatmap"))
+            group_layout = QVBoxLayout(group)
+
+            # Metric selector
+            combo_row = QHBoxLayout()
+            combo_row.addWidget(QLabel(strings._("stats_heatmap_metric")))
+            self.metric_combo = QComboBox()
+            self.metric_combo.addItem(strings._("stats_metric_words"), "words")
+            self.metric_combo.addItem(strings._("stats_metric_revisions"), "revisions")
+            combo_row.addWidget(self.metric_combo)
+            combo_row.addStretch(1)
+            group_layout.addLayout(combo_row)
+
+            self._heatmap = DateHeatmap()
+            self._words_by_date = words_by_date
+            self._revisions_by_date = revisions_by_date
+
+            scroll = QScrollArea()
+            scroll.setWidgetResizable(True)
+            scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+            scroll.setWidget(self._heatmap)
+            group_layout.addWidget(scroll)
+
+            root.addWidget(group)
+
+            # Default to "words"
+            self._apply_metric("words")
+            self.metric_combo.currentIndexChanged.connect(self._on_metric_changed)
+        else:
+            root.addWidget(QLabel(strings._("stats_no_data")))
+
+    # ---------- internal helpers ----------
+
+    def _apply_metric(self, metric: str) -> None:
+        if metric == "revisions":
+            self._heatmap.set_data(self._revisions_by_date)
+        else:
+            self._heatmap.set_data(self._words_by_date)
+
+    def _on_metric_changed(self, index: int) -> None:
+        metric = self.metric_combo.currentData()
+        if metric:
+            self._apply_metric(metric)
+
+    def _gather_stats(self):
+        return self._db.gather_stats()

{bouquin-0.3 → bouquin-0.3.1}/bouquin/tag_browser.py

@@ -1,4 +1,3 @@
-# tag_browser.py
 from PySide6.QtCore import Qt, Signal
 from PySide6.QtGui import QColor
 from PySide6.QtWidgets import (
@@ -11,6 +10,7 @@ from PySide6.QtWidgets import (
     QLabel,
     QColorDialog,
     QMessageBox,
+    QInputDialog,
 )
 
 from .db import DBManager
@@ -52,6 +52,10 @@ class TagBrowserDialog(QDialog):
         # Tag management buttons
         btn_row = QHBoxLayout()
 
+        self.add_tag_btn = QPushButton(strings._("add_a_tag"))
+        self.add_tag_btn.clicked.connect(self._add_a_tag)
+        btn_row.addWidget(self.add_tag_btn)
+
         self.edit_name_btn = QPushButton(strings._("edit_tag_name"))
         self.edit_name_btn.clicked.connect(self._edit_tag_name)
         self.edit_name_btn.setEnabled(False)
@@ -155,6 +159,23 @@ class TagBrowserDialog(QDialog):
                     self.openDateRequested.emit(date_iso)
                     self.accept()
 
+    def _add_a_tag(self):
+        """Add a new tag"""
+
+        new_name, ok = QInputDialog.getText(
+            self, strings._("add_a_tag"), strings._("new_tag_name"), text=""
+        )
+
+        if ok and new_name:
+            color = QColorDialog.getColor(QColor(), self)
+            if color.isValid():
+                try:
+                    self._db.add_tag(new_name, color.name())
+                    self._populate(None)
+                    self.tagsModified.emit()
+                except IntegrityError as e:
+                    QMessageBox.critical(self, strings._("db_database_error"), str(e))
+
     def _edit_tag_name(self):
         """Edit the name of the selected tag"""
         item = self.tree.currentItem()
@@ -169,9 +190,6 @@ class TagBrowserDialog(QDialog):
         old_name = data["name"]
         color = data["color"]
 
-        # Simple input dialog
-        from PySide6.QtWidgets import QInputDialog
-
         new_name, ok = QInputDialog.getText(
             self, strings._("edit_tag_name"), strings._("new_tag_name"), text=old_name
         )

{bouquin-0.3 → bouquin-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bouquin"
-version = "0.3"
+version = "0.3.1"
 description = "Bouquin is a simple, opinionated notebook application written in Python, PyQt and SQLCipher."
 authors = ["Miguel Jacq <mig@mig5.net>"]
 readme = "README.md"