bouquin 0.3.1__tar.gz → 0.4__tar.gz

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

@@ -1,19 +1,19 @@
 Metadata-Version: 2.1
 Name: bouquin
-Version: 0.3.1
+Version: 0.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
 Author: Miguel Jacq
 Author-email: mig@mig5.net
-Requires-Python: >=3.9,<3.14
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: pyside6 (>=6.8.1,<7.0.0)
+Requires-Dist: requests (>=2.32.5,<3.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
@@ -23,7 +23,11 @@ Description-Content-Type: text/markdown
 
 ## Introduction
 
-Bouquin ("Book-ahn") is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
+Bouquin ("Book-ahn") is a notebook and planner application written in Python, PyQt and SQLCipher.
+
+It is designed to treat each day as its own 'page', complete with Markdown rendering, tagging,
+search, reminders and time logging for those of us who need to keep track of not just TODOs, but
+also how long we spent on them.
 
 It uses [SQLCipher bindings](https://pypi.org/project/sqlcipher3-wheels) as a drop-in replacement
 for SQLite3. This means that the underlying database for the notebook is encrypted at rest.
@@ -31,35 +35,39 @@ for SQLite3. This means that the underlying database for the notebook is encrypt
 To increase security, the SQLCipher key is requested when the app is opened, and is not written
 to disk unless the user configures it to be in the settings.
 
-There is deliberately no network connectivity or syncing intended.
+There is deliberately no network connectivity or syncing intended, other than the option to send a bug
+report from within the app.
 
 ## Screenshots
 
+### General view
 ![Screenshot of Bouquin](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/screenshot.png)
+
+### History panes
 ![Screenshot of Bouquin History Preview pane](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/history_preview.png)
 ![Screenshot of Bouquin History Diff pane](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/history_diff.png)
 
-## Features
+## Some of the 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
  * All changes are version controlled, with ability to view/diff versions and revert
- * Text is Markdown with basic styling
+ * Automatic rendering of basic Markdown syntax
  * 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
+ * Search all pages, or find text on current page
+ * Add and manage tags
  * 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)
  * Rekey the database (change the password)
  * 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
+ * Dark and light theme support
  * Automatically generate checkboxes when typing 'TODO'
  * It is possible to automatically move unchecked checkboxes from yesterday to today, on startup
  * English, French and Italian locales provided
+ * Ability to set reminder alarms in the app against the current line of text on today's date
+ * Ability to log time per day and run timesheet reports
 
 
 ## How to install

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

@@ -3,7 +3,11 @@
 
 ## Introduction
 
-Bouquin ("Book-ahn") is a simple, opinionated notebook application written in Python, PyQt and SQLCipher.
+Bouquin ("Book-ahn") is a notebook and planner application written in Python, PyQt and SQLCipher.
+
+It is designed to treat each day as its own 'page', complete with Markdown rendering, tagging,
+search, reminders and time logging for those of us who need to keep track of not just TODOs, but
+also how long we spent on them.
 
 It uses [SQLCipher bindings](https://pypi.org/project/sqlcipher3-wheels) as a drop-in replacement
 for SQLite3. This means that the underlying database for the notebook is encrypted at rest.
@@ -11,35 +15,39 @@ for SQLite3. This means that the underlying database for the notebook is encrypt
 To increase security, the SQLCipher key is requested when the app is opened, and is not written
 to disk unless the user configures it to be in the settings.
 
-There is deliberately no network connectivity or syncing intended.
+There is deliberately no network connectivity or syncing intended, other than the option to send a bug
+report from within the app.
 
 ## Screenshots
 
+### General view
 ![Screenshot of Bouquin](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/screenshot.png)
+
+### History panes
 ![Screenshot of Bouquin History Preview pane](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/history_preview.png)
 ![Screenshot of Bouquin History Diff pane](https://git.mig5.net/mig5/bouquin/raw/branch/main/screenshots/history_diff.png)
 
-## Features
+## Some of the 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
  * All changes are version controlled, with ability to view/diff versions and revert
- * Text is Markdown with basic styling
+ * Automatic rendering of basic Markdown syntax
  * 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
+ * Search all pages, or find text on current page
+ * Add and manage tags
  * 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)
  * Rekey the database (change the password)
  * 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
+ * Dark and light theme support
  * Automatically generate checkboxes when typing 'TODO'
  * It is possible to automatically move unchecked checkboxes from yesterday to today, on startup
  * English, French and Italian locales provided
+ * Ability to set reminder alarms in the app against the current line of text on today's date
+ * Ability to log time per day and run timesheet reports
 
 
 ## How to install

bouquin-0.4/bouquin/bug_report_dialog.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import importlib.metadata
+
+import requests
+
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QLabel,
+    QTextEdit,
+    QDialogButtonBox,
+    QMessageBox,
+)
+
+from . import strings
+
+
+BUG_REPORT_HOST = "https://nr.mig5.net"
+ROUTE = "forms/bouquin/bugs"
+
+
+class BugReportDialog(QDialog):
+    """
+    Dialog to collect a bug report
+    """
+
+    MAX_CHARS = 5000
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(strings._("report_a_bug"))
+
+        layout = QVBoxLayout(self)
+
+        header = QLabel(strings._("bug_report_explanation"))
+        header.setWordWrap(True)
+        layout.addWidget(header)
+
+        self.text_edit = QTextEdit()
+        self.text_edit.setPlaceholderText(strings._("bug_report_placeholder"))
+        layout.addWidget(self.text_edit)
+
+        self.text_edit.textChanged.connect(self._enforce_max_length)
+
+        # Buttons: Cancel / Send
+        button_box = QDialogButtonBox(QDialogButtonBox.Cancel)
+        button_box.addButton(strings._("send"), QDialogButtonBox.AcceptRole)
+        button_box.accepted.connect(self._send)
+        button_box.rejected.connect(self.reject)
+        layout.addWidget(button_box)
+
+        self.setMinimumWidth(560)
+
+        self.text_edit.setFocus()
+
+    # ------------Helpers ------------ #
+
+    def _enforce_max_length(self):
+        text = self.text_edit.toPlainText()
+        if len(text) <= self.MAX_CHARS:
+            return
+
+        # Remember cursor position
+        cursor = self.text_edit.textCursor()
+        pos = cursor.position()
+
+        # Trim and restore without re-entering this slot
+        self.text_edit.blockSignals(True)
+        self.text_edit.setPlainText(text[: self.MAX_CHARS])
+        self.text_edit.blockSignals(False)
+
+        # Clamp cursor position to end of text
+        if pos > self.MAX_CHARS:
+            pos = self.MAX_CHARS
+
+        cursor.setPosition(pos)
+        self.text_edit.setTextCursor(cursor)
+
+    def _send(self):
+        text = self.text_edit.toPlainText().strip()
+        if not text:
+            QMessageBox.warning(
+                self,
+                strings._("report_a_bug"),
+                strings._("bug_report_empty"),
+            )
+            return
+
+        # Get current app version
+        try:
+            version = importlib.metadata.version("bouquin")
+        except importlib.metadata.PackageNotFoundError:
+            version = "unknown"
+
+        payload: dict[str, str] = {
+            "message": text,
+            "version": version,
+        }
+
+        # POST as JSON
+        try:
+            resp = requests.post(
+                f"{BUG_REPORT_HOST}/{ROUTE}",
+                json=payload,
+                timeout=10,
+            )
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                strings._("report_a_bug"),
+                strings._("bug_report_send_failed") + f"\n{e}",
+            )
+            return
+
+        if resp.status_code == 201:
+            QMessageBox.information(
+                self,
+                strings._("report_a_bug"),
+                strings._("bug_report_sent_ok"),
+            )
+            self.accept()
+        else:
+            QMessageBox.critical(
+                self,
+                strings._("report_a_bug"),
+                strings._("bug_report_send_failed") + f" (HTTP {resp.status_code})",
+            )

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

@@ -17,6 +17,18 @@ from . import strings
 
 Entry = Tuple[str, str]
 TagRow = Tuple[int, str, str]
+ProjectRow = Tuple[int, str]  # (id, name)
+ActivityRow = Tuple[int, str]  # (id, name)
+TimeLogRow = Tuple[
+    int,  # id
+    str,  # page_date (yyyy-MM-dd)
+    int,
+    str,  # project_id, project_name
+    int,
+    str,  # activity_id, activity_name
+    int,  # minutes
+    str | None,  # note
+]
 
 _TAG_COLORS = [
     "#FFB3BA",  # soft red
@@ -148,6 +160,38 @@ class DBManager:
             );
 
             CREATE INDEX IF NOT EXISTS ix_page_tags_tag_id ON page_tags(tag_id);
+
+            CREATE TABLE IF NOT EXISTS projects (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL UNIQUE
+            );
+
+            CREATE TABLE IF NOT EXISTS activities (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL UNIQUE
+            );
+
+            CREATE TABLE IF NOT EXISTS time_log (
+                id INTEGER PRIMARY KEY,
+                page_date TEXT NOT NULL,               -- FK to pages.date (yyyy-MM-dd)
+                project_id INTEGER NOT NULL,           -- FK to projects.id
+                activity_id INTEGER NOT NULL,          -- FK to activities.id
+                minutes INTEGER NOT NULL,              -- duration in minutes
+                note TEXT,
+                created_at TEXT NOT NULL DEFAULT (
+                    strftime('%Y-%m-%dT%H:%M:%fZ','now')
+                ),
+                FOREIGN KEY(page_date) REFERENCES pages(date) ON DELETE CASCADE,
+                FOREIGN KEY(project_id) REFERENCES projects(id) ON DELETE RESTRICT,
+                FOREIGN KEY(activity_id) REFERENCES activities(id) ON DELETE RESTRICT
+            );
+
+            CREATE INDEX IF NOT EXISTS ix_time_log_date
+                ON time_log(page_date);
+            CREATE INDEX IF NOT EXISTS ix_time_log_project
+                ON time_log(project_id);
+            CREATE INDEX IF NOT EXISTS ix_time_log_activity
+                ON time_log(activity_id);
             """
         )
         self.conn.commit()
@@ -433,7 +477,7 @@ class DBManager:
         """
         if not name:
             return "#CCCCCC"
-        h = int(hashlib.sha1(name.encode("utf-8")).hexdigest()[:8], 16)
+        h = int(hashlib.sha1(name.encode("utf-8")).hexdigest()[:8], 16)  # nosec
         return _TAG_COLORS[h % len(_TAG_COLORS)]
 
     # -------- Tags: per-page -------------------------------------------
@@ -514,7 +558,7 @@ class DBManager:
                 SELECT id, name
                 FROM tags
                 WHERE name IN ({placeholders});
-                """,
+                """,  # nosec
                 tuple(final_tag_names),
             ).fetchall()
             ids_by_name = {r["name"]: r["id"] for r in rows}
@@ -746,6 +790,220 @@ class DBManager:
             revisions_by_date,
         )
 
+    # -------- Time logging: projects & activities ---------------------
+
+    def list_projects(self) -> list[ProjectRow]:
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            "SELECT id, name FROM projects ORDER BY LOWER(name);"
+        ).fetchall()
+        return [(r["id"], r["name"]) for r in rows]
+
+    def add_project(self, name: str) -> int:
+        name = name.strip()
+        if not name:
+            raise ValueError("empty project name")
+        with self.conn:
+            cur = self.conn.cursor()
+            cur.execute(
+                "INSERT OR IGNORE INTO projects(name) VALUES (?);",
+                (name,),
+            )
+        row = cur.execute(
+            "SELECT id, name FROM projects WHERE name = ?;",
+            (name,),
+        ).fetchone()
+        return row["id"]
+
+    def rename_project(self, project_id: int, new_name: str) -> None:
+        new_name = new_name.strip()
+        if not new_name:
+            return
+        with self.conn:
+            self.conn.execute(
+                "UPDATE projects SET name = ? WHERE id = ?;",
+                (new_name, project_id),
+            )
+
+    def delete_project(self, project_id: int) -> None:
+        with self.conn:
+            self.conn.execute(
+                "DELETE FROM projects WHERE id = ?;",
+                (project_id,),
+            )
+
+    def list_activities(self) -> list[ActivityRow]:
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            "SELECT id, name FROM activities ORDER BY LOWER(name);"
+        ).fetchall()
+        return [(r["id"], r["name"]) for r in rows]
+
+    def add_activity(self, name: str) -> int:
+        name = name.strip()
+        if not name:
+            raise ValueError("empty activity name")
+        with self.conn:
+            cur = self.conn.cursor()
+            cur.execute(
+                "INSERT OR IGNORE INTO activities(name) VALUES (?);",
+                (name,),
+            )
+        row = cur.execute(
+            "SELECT id, name FROM activities WHERE name = ?;",
+            (name,),
+        ).fetchone()
+        return row["id"]
+
+    def rename_activity(self, activity_id: int, new_name: str) -> None:
+        new_name = new_name.strip()
+        if not new_name:
+            return
+        with self.conn:
+            self.conn.execute(
+                "UPDATE activities SET name = ? WHERE id = ?;",
+                (new_name, activity_id),
+            )
+
+    def delete_activity(self, activity_id: int) -> None:
+        with self.conn:
+            self.conn.execute(
+                "DELETE FROM activities WHERE id = ?;",
+                (activity_id,),
+            )
+
+    # -------- Time logging: entries -----------------------------------
+
+    def add_time_log(
+        self,
+        date_iso: str,
+        project_id: int,
+        activity_id: int,
+        minutes: int,
+        note: str | None = None,
+    ) -> int:
+        with self.conn:
+            cur = self.conn.cursor()
+            # Ensure a page row exists even if there is no text content yet
+            cur.execute("INSERT OR IGNORE INTO pages(date) VALUES (?);", (date_iso,))
+            cur.execute(
+                """
+                INSERT INTO time_log(page_date, project_id, activity_id, minutes, note)
+                VALUES (?, ?, ?, ?, ?);
+                """,
+                (date_iso, project_id, activity_id, minutes, note),
+            )
+            return cur.lastrowid
+
+    def update_time_log(
+        self,
+        entry_id: int,
+        project_id: int,
+        activity_id: int,
+        minutes: int,
+        note: str | None = None,
+    ) -> None:
+        with self.conn:
+            self.conn.execute(
+                """
+                UPDATE time_log
+                SET project_id = ?, activity_id = ?, minutes = ?, note = ?
+                WHERE id = ?;
+                """,
+                (project_id, activity_id, minutes, note, entry_id),
+            )
+
+    def delete_time_log(self, entry_id: int) -> None:
+        with self.conn:
+            self.conn.execute(
+                "DELETE FROM time_log WHERE id = ?;",
+                (entry_id,),
+            )
+
+    def time_log_for_date(self, date_iso: str) -> list[TimeLogRow]:
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            """
+            SELECT
+                t.id,
+                t.page_date,
+                t.project_id,
+                p.name AS project_name,
+                t.activity_id,
+                a.name AS activity_name,
+                t.minutes,
+                t.note
+            FROM time_log t
+            JOIN projects  p ON p.id = t.project_id
+            JOIN activities a ON a.id = t.activity_id
+            WHERE t.page_date = ?
+            ORDER BY LOWER(p.name), LOWER(a.name), t.id;
+            """,
+            (date_iso,),
+        ).fetchall()
+
+        result: list[TimeLogRow] = []
+        for r in rows:
+            result.append(
+                (
+                    r["id"],
+                    r["page_date"],
+                    r["project_id"],
+                    r["project_name"],
+                    r["activity_id"],
+                    r["activity_name"],
+                    r["minutes"],
+                    r["note"],
+                )
+            )
+        return result
+
+    def time_report(
+        self,
+        project_id: int,
+        start_date_iso: str,
+        end_date_iso: str,
+        granularity: str = "day",  # 'day' | 'week' | 'month'
+    ) -> list[tuple[str, str, int]]:
+        """
+        Return (time_period, activity_name, total_minutes) tuples between start and end
+        for a project, grouped by period and activity.
+        time_period is:
+          - 'YYYY-MM-DD' for day
+          - 'YYYY-WW'    for week
+          - 'YYYY-MM'    for month
+        """
+        if granularity == "day":
+            bucket_expr = "page_date"
+        elif granularity == "week":
+            # ISO-like year-week; SQLite weeks start at 00
+            bucket_expr = "strftime('%Y-%W', page_date)"
+        else:  # month
+            bucket_expr = "substr(page_date, 1, 7)"  # YYYY-MM
+
+        cur = self.conn.cursor()
+        rows = cur.execute(
+            f"""
+            SELECT
+                {bucket_expr} AS bucket,
+                a.name         AS activity_name,
+                t.note         AS note,
+                SUM(t.minutes) AS total_minutes
+            FROM time_log t
+            JOIN activities a ON a.id = t.activity_id
+            WHERE t.project_id = ?
+              AND t.page_date BETWEEN ? AND ?
+            GROUP BY bucket, activity_name
+            ORDER BY bucket, LOWER(activity_name);
+            """,  # nosec
+            (project_id, start_date_iso, end_date_iso),
+        ).fetchall()
+
+        return [
+            (r["bucket"], r["activity_name"], r["note"], r["total_minutes"])
+            for r in rows
+        ]
+
     def close(self) -> None:
         if self.conn is not None:
             self.conn.close()

bouquin-0.4/bouquin/key_prompt.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from PySide6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QDialogButtonBox,
+    QFileDialog,
+)
+
+from . import strings
+
+
+class KeyPrompt(QDialog):
+    def __init__(
+        self,
+        parent=None,
+        title: str = strings._("key_prompt_enter_key"),
+        message: str = strings._("key_prompt_enter_key"),
+        initial_db_path: str | Path | None = None,
+        show_db_change: bool = False,
+    ):
+        """
+        Prompt the user for the key required to decrypt the database.
+
+        Used when opening the app, unlocking the idle locked screen,
+        or when rekeying.
+
+        If show_db_change is true, also show a QFileDialog allowing to
+        select a database file, else the default from settings is used.
+        """
+        super().__init__(parent)
+        self.setWindowTitle(title)
+
+        self._db_path: Path | None = Path(initial_db_path) if initial_db_path else None
+
+        v = QVBoxLayout(self)
+
+        v.addWidget(QLabel(message))
+
+        # DB chooser
+        self.path_edit: QLineEdit | None = None
+        if show_db_change:
+            path_row = QHBoxLayout()
+            self.path_edit = QLineEdit()
+            if self._db_path is not None:
+                self.path_edit.setText(str(self._db_path))
+
+            browse_btn = QPushButton(strings._("select_notebook"))
+
+            def _browse():
+                start_dir = str(self._db_path or "")
+                fname, _ = QFileDialog.getOpenFileName(
+                    self,
+                    strings._("select_notebook"),
+                    start_dir,
+                    "SQLCipher DB (*.db);;All files (*)",
+                )
+                if fname:
+                    self._db_path = Path(fname)
+                    if self.path_edit is not None:
+                        self.path_edit.setText(fname)
+
+            browse_btn.clicked.connect(_browse)
+
+            path_row.addWidget(self.path_edit, 1)
+            path_row.addWidget(browse_btn)
+            v.addLayout(path_row)
+
+        # Key entry
+        self.key_entry = QLineEdit()
+        self.key_entry.setEchoMode(QLineEdit.Password)
+        v.addWidget(self.key_entry)
+
+        toggle = QPushButton(strings._("show"))
+        toggle.setCheckable(True)
+        toggle.toggled.connect(
+            lambda c: self.key_entry.setEchoMode(
+                QLineEdit.Normal if c else QLineEdit.Password
+            )
+        )
+        v.addWidget(toggle)
+
+        bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        bb.accepted.connect(self.accept)
+        bb.rejected.connect(self.reject)
+        v.addWidget(bb)
+
+        self.key_entry.setFocus()
+        self.resize(500, self.sizeHint().height())
+
+    def key(self) -> str:
+        return self.key_entry.text()
+
+    def db_path(self) -> Path | None:
+        """Return the chosen DB path (or None if unchanged/not shown)."""
+        if self.path_edit is not None:
+            text = self.path_edit.text().strip()
+            if text:
+                return Path(text)
+        return self._db_path