telepost-bot 2.78.0__py3-none-any.whl

telepost/observability/errors.py

@@ -0,0 +1,51 @@
+"""Map exceptions (and optional HTTP statuses) to stable error class strings.
+
+Specific exception types win over a coarse HTTP status, so an upstream 502
+wrapping a timeout keeps the true cause.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+
+def classify(exc: Optional[BaseException], status: Optional[int] = None) -> str:
+    if exc is not None:
+        module = type(exc).__module__ or ""
+        name = type(exc).__name__ or ""
+
+        if module.startswith("telegram.error") or module.startswith("telegram."):
+            if name in ("TimedOut",):
+                return "network_timeout"
+            if name in ("RetryAfter", "TelegramRetryAfter"):
+                return "rate_limited"
+            if name == "BadRequest":
+                return "telegram_send_failed"
+
+        try:
+            import aiosqlite
+            if isinstance(exc, aiosqlite.Error):
+                return "database_failed"
+        except ImportError:  # pragma: no cover
+            pass
+
+        code = str(getattr(exc, "code", "") or "")
+        if code == "duplicate_publication":
+            return "duplicate"
+        text = f"{name} {exc}".lower()
+        if "decode" in text and "budget" in text:
+            return "media_decode_budget_exceeded"
+        if module.startswith("PIL.") or name in (
+            "UnidentifiedImageError", "DecompressionBombError"
+        ):
+            return "media_processing_failed"
+
+    if isinstance(status, int):
+        if status == 409:
+            return "idempotency_conflict"
+        if status == 429:
+            return "rate_limited"
+        if 500 <= status < 600:
+            return "remote_5xx"
+        if 400 <= status < 500:
+            return "remote_4xx"
+    return "internal_error"

telepost/observability/redact.py

@@ -0,0 +1,76 @@
+"""Best-effort secret redaction for logs and audit details.
+
+Stdlib only. The rules deliberately stay simple: miss an obscure leak rather
+ than build a secret-detection engine.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_MASK = "***"
+
+# Telegram bot tokens look like 123456789:AA... (8-10 digit bot id, colon,
+# 35-ish base64url-ish chars).
+_BOT_TOKEN_RE = re.compile(r"\d{6,}:[A-Za-z0-9_-]{20,}")
+_BEARER_RE = re.compile(r"(?i:\bBearer\s+)[A-Za-z0-9._\-]+")
+# token=/secret=/password= URL/form params.
+_PARAM_RE = re.compile(
+    r"(?i:((?:^|[?;&\s])(?:token|secret|password|api[_-]?key)\s*=\s*))[^&\s;\"']+"
+)
+
+_SENSITIVE_HEADERS = {
+    "authorization",
+    "cookie",
+    "x-telegram-bot-api-secret-token",
+}
+_SENSITIVE_KEY_PARTS = ("token", "secret", "password", "api_key", "apikey")
+
+
+def redact_text(value: str) -> str:
+    """Mask bot tokens, Bearer credentials and secret-ish params in a string."""
+    if not isinstance(value, str):
+        value = str(value)
+    value = _BOT_TOKEN_RE.sub(_MASK, value)
+    value = _BEARER_RE.sub(lambda m: m.group(0).split()[0] + " " + _MASK, value)
+    value = _PARAM_RE.sub(lambda m: m.group(1) + _MASK, value)
+    return value
+
+
+def redact_headers(headers: Any) -> dict:
+    """Return a copy of a headers mapping with sensitive values masked."""
+    try:
+        items = headers.items()
+    except AttributeError:
+        return {}
+    out = {}
+    for key, value in items:
+        lname = str(key).lower()
+        if lname in _SENSITIVE_HEADERS or any(
+            part in lname for part in _SENSITIVE_KEY_PARTS
+        ):
+            out[key] = _MASK
+        else:
+            out[key] = redact_text(str(value))
+    return out
+
+
+def sanitize_detail(obj: Any) -> Any:
+    """Recursively mask sensitive keys and redact string values."""
+    if isinstance(obj, dict):
+        return {
+            key: _MASK if _is_sensitive_key(key) else sanitize_detail(value)
+            for key, value in obj.items()
+        }
+    if isinstance(obj, (list, tuple)):
+        return [sanitize_detail(value) for value in obj]
+    if isinstance(obj, str):
+        return redact_text(obj)
+    return obj
+
+
+def _is_sensitive_key(key: Any) -> bool:
+    lname = str(key).lower()
+    return lname in _SENSITIVE_HEADERS or any(
+        part in lname for part in _SENSITIVE_KEY_PARTS
+    )

telepost/storage/sqlite/automation.py

@@ -0,0 +1,185 @@
+"""Automation task storage: SQLite CRUD and durable run ledger.
+
+Two tables:
+- ``automation_tasks``: persistent rule SSOT. JobQueue is a runtime projection.
+- ``automation_runs``: (task_id, occurrence_at) UNIQUE — one send per occurrence.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import List, Optional
+
+from database.db_manager import get_db
+from telepost.domain.automation import AutomationTask, parse_automation_payload
+
+logger = logging.getLogger(__name__)
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS automation_tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    schedule_type TEXT NOT NULL DEFAULT 'weekly',
+    schedule_day INTEGER NOT NULL DEFAULT 6,
+    schedule_hour INTEGER NOT NULL DEFAULT 20,
+    schedule_minute INTEGER NOT NULL DEFAULT 0,
+    action_type TEXT NOT NULL DEFAULT 'hot',
+    action_payload TEXT NOT NULL DEFAULT '{}',
+    target_chat_id TEXT NOT NULL DEFAULT '',
+    timezone TEXT NOT NULL DEFAULT 'Asia/Shanghai',
+    created_by INTEGER NOT NULL DEFAULT 0,
+    created_at REAL NOT NULL DEFAULT 0,
+    updated_at REAL NOT NULL DEFAULT 0,
+    last_run_at REAL,
+    last_run_status TEXT,
+    last_error TEXT
+);
+CREATE TABLE IF NOT EXISTS automation_runs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id INTEGER NOT NULL REFERENCES automation_tasks(id),
+    occurrence_at REAL NOT NULL,
+    trigger TEXT NOT NULL DEFAULT 'scheduled',
+    status TEXT NOT NULL DEFAULT 'running',
+    error TEXT,
+    started_at REAL NOT NULL DEFAULT 0,
+    finished_at REAL,
+    UNIQUE(task_id, occurrence_at)
+);
+"""
+
+
+async def ensure_tables() -> None:
+    async with get_db() as conn:
+        await conn.executescript(_SCHEMA)
+        await conn.commit()
+
+
+def _row_to_task(row) -> AutomationTask:
+    return AutomationTask(
+        id=row["id"],
+        name=row["name"],
+        enabled=bool(row["enabled"]),
+        schedule_type=row["schedule_type"],
+        schedule_day=row["schedule_day"],
+        schedule_hour=row["schedule_hour"],
+        schedule_minute=row["schedule_minute"],
+        action_type=row["action_type"],
+        action_payload=parse_automation_payload(row["action_payload"]),
+        target_chat_id=row["target_chat_id"],
+        timezone=row["timezone"],
+        created_by=row["created_by"],
+        created_at=row["created_at"],
+        updated_at=row["updated_at"],
+        last_run_at=row["last_run_at"],
+        last_run_status=row["last_run_status"],
+        last_error=row["last_error"],
+    )
+
+
+async def create_task(task: AutomationTask) -> AutomationTask:
+    now = time.time()
+    async with get_db() as conn:
+        cursor = await conn.execute(
+            """INSERT INTO automation_tasks
+               (name, enabled, schedule_type, schedule_day, schedule_hour,
+                schedule_minute, action_type, action_payload, target_chat_id,
+                timezone, created_by, created_at, updated_at)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+            (
+                task.name, int(task.enabled), task.schedule_type,
+                task.schedule_day, task.schedule_hour, task.schedule_minute,
+                task.action_type, json.dumps(task.action_payload),
+                task.target_chat_id, task.timezone, task.created_by,
+                now, now,
+            ),
+        )
+        task_id = cursor.lastrowid
+        await conn.commit()
+    task.id = task_id
+    task.created_at = now
+    task.updated_at = now
+    return task
+
+
+async def list_tasks() -> List[AutomationTask]:
+    async with get_db() as conn:
+        cursor = await conn.execute(
+            "SELECT * FROM automation_tasks ORDER BY id"
+        )
+        rows = await cursor.fetchall()
+    return [_row_to_task(r) for r in rows]
+
+
+async def get_task(task_id: int) -> Optional[AutomationTask]:
+    async with get_db() as conn:
+        cursor = await conn.execute(
+            "SELECT * FROM automation_tasks WHERE id = ?", (task_id,)
+        )
+        row = await cursor.fetchone()
+    return _row_to_task(row) if row else None
+
+
+async def set_enabled(task_id: int, enabled: bool) -> bool:
+    async with get_db() as conn:
+        cursor = await conn.execute(
+            "UPDATE automation_tasks SET enabled = ?, updated_at = ? WHERE id = ?",
+            (int(enabled), time.time(), task_id),
+        )
+        await conn.commit()
+        return cursor.rowcount > 0
+
+
+async def delete_task(task_id: int) -> bool:
+    async with get_db() as conn:
+        cursor = await conn.execute(
+            "DELETE FROM automation_tasks WHERE id = ?", (task_id,)
+        )
+        await conn.commit()
+        return cursor.rowcount > 0
+
+
+async def update_run_result(
+    task_id: int, occurrence_at: float, status: str, error: Optional[str] = None
+) -> None:
+    now = time.time()
+    async with get_db() as conn:
+        await conn.execute(
+            """UPDATE automation_tasks
+               SET last_run_at = ?, last_run_status = ?, last_error = ?, updated_at = ?
+               WHERE id = ?""",
+            (occurrence_at, status, error, now, task_id),
+        )
+        await conn.commit()
+
+
+async def record_run_start(
+    task_id: int, occurrence_at: float, trigger: str
+) -> bool:
+    """Insert a run record; return False if (task_id, occurrence_at) already exists."""
+    async with get_db() as conn:
+        try:
+            await conn.execute(
+                """INSERT INTO automation_runs
+                   (task_id, occurrence_at, trigger, status, started_at)
+                   VALUES (?,?,?,?,?)""",
+                (task_id, occurrence_at, trigger, "running", time.time()),
+            )
+            await conn.commit()
+            return True
+        except Exception:
+            return False
+
+
+async def record_run_finish(
+    task_id: int, occurrence_at: float, status: str, error: Optional[str] = None
+) -> None:
+    async with get_db() as conn:
+        await conn.execute(
+            """UPDATE automation_runs
+               SET status = ?, error = ?, finished_at = ?
+               WHERE task_id = ? AND occurrence_at = ?""",
+            (status, error, time.time(), task_id, occurrence_at),
+        )
+        await conn.commit()

telepost/storage/sqlite/columns.py

@@ -0,0 +1,18 @@
+"""Storage column names behind source-neutral domain names (§naming-map).
+
+The domain/application layer calls a work's upstream identity ``work_id``
+(source-neutral). The persisted column predates that vocabulary and keeps its
+historical name forever (constraint: zero-renames on storage). All SQL that
+touches the column should reference this constant instead of scattering the
+literal, so the wire→domain→storage mapping has exactly one home:
+
+    wire ``work_id`` (preferred) / ``pixiv_id`` (deprecated alias)
+      → domain ``work_id``
+      → storage column ``WORK_ID_COLUMN`` ("pixiv_id", immutable)
+
+Audit payloads also keep the historical ``pixiv_id`` key: audit_events rows
+are a persisted schema that old readers may still consume.
+"""
+
+#: The immutable storage column carrying the domain ``work_id``.
+WORK_ID_COLUMN = "pixiv_id"

telepost/storage/sqlite/editorial.py

@@ -0,0 +1,226 @@
+"""Editorial Revision durable storage (§editorial).
+
+Revisions are a separate ledger from the Review FSM: a revision row never
+changes ``pending_reviews.status``, and the review flow never reads revision
+rows to decide whether publication is allowed. The only coupling is:
+
+* the review row carries ``published_source_revision_id`` (NULL = original
+  publish), recorded by the publication service AFTER a confirmed delivery;
+* a finalized revision is required before it may be published;
+* when a review is superseded/decided, its open drafts are terminalized
+  (``superseded``) so a stale editor can never publish a stale generation.
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Dict, List, Optional
+
+from database.db_manager import get_db
+
+from ...domain import editorial as domain
+
+RevisionRow = Dict[str, Any]
+
+
+class EditorialConflictError(Exception):
+    """CAS/version conflict: another editor moved the revision first (409)."""
+
+
+class EditorialNotFoundError(Exception):
+    """Revision does not exist (404)."""
+
+
+class EditorialStateError(Exception):
+    """Operation illegal in the current revision state (409)."""
+
+
+def _stamp(now: Optional[float] = None) -> float:
+    return time.time() if now is None else float(now)
+
+
+class EditorialRepository:
+    """SQLite repository keyed on review rows (pending_reviews)."""
+
+    async def create(self, review_id: int, review_chain_id: str, base: domain.Snapshot,
+                     editor_user_id: Optional[int], editor_username: str = "",
+                     editor_display_name: str = "",
+                     connection: Any = None) -> Dict[str, Any]:
+        """Create the next draft revision for a review.
+
+        Revision numbering is data-layer monotonic and race-safe: the number is
+        allocated inside a transaction and the UNIQUE(review_id, revision_number)
+        constraint rejects a concurrent duplicate; a loser of that race retries
+        once with the fresh maximum.
+        """
+        now = _stamp()
+        async with (connection or get_db()) as conn:
+            for _attempt in range(2):
+                cur = await conn.execute(
+                    "SELECT COALESCE(MAX(revision_number), 0) + 1 AS next "
+                    "FROM editorial_revisions WHERE review_id = ?",
+                    (int(review_id),),
+                )
+                row = await cur.fetchone()
+                number = int(row["next"]) if row else 1
+                try:
+                    cur = await conn.execute(
+                        """
+                        INSERT INTO editorial_revisions (
+                          review_id, review_chain_id, revision_number, status,
+                          base_snapshot, edited_snapshot, change_set, summary,
+                          editor_user_id, editor_username, editor_display_name,
+                          version, created_at, updated_at
+                        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                        """,
+                        (
+                            int(review_id), review_chain_id, number,
+                            domain.RevisionStatus.DRAFT.value,
+                            json.dumps(base.to_dict(), ensure_ascii=False),
+                            json.dumps(base.to_dict(), ensure_ascii=False),
+                            "{}", "",
+                            editor_user_id, editor_username, editor_display_name,
+                            1, now, now,
+                        ),
+                    )
+                    return await self._select_in_conn(conn, cur.lastrowid)
+                except Exception as exc:
+                    if "UNIQUE" in str(exc).upper() or getattr(exc, "sqlite_errorcode", None) == 2067:
+                        continue  # concurrent number allocation; retry once
+                    raise
+        raise EditorialConflictError("无法分配 revision 编号，请重试")
+
+    async def get(self, revision_id: int) -> Optional[Dict[str, Any]]:
+        async with get_db() as conn:
+            return await self._select_in_conn(conn, int(revision_id))
+
+    async def get_for_review(self, review_id: int, revision_id: int) -> Optional[Dict[str, Any]]:
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "SELECT * FROM editorial_revisions WHERE id = ? AND review_id = ?",
+                (int(revision_id), int(review_id)),
+            )
+            row = await cur.fetchone()
+            return dict(row) if row else None
+
+    async def list_for_review(self, review_id: int) -> List[Dict[str, Any]]:
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "SELECT * FROM editorial_revisions WHERE review_id = ? "
+                "ORDER BY revision_number ASC", (int(review_id),),
+            )
+            return [dict(r) for r in await cur.fetchall()]
+
+    async def list_published_for_chain(self, review_chain_id: str) -> List[Dict[str, Any]]:
+        """Submitter-safe published history (one logical submission, §36)."""
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "SELECT * FROM editorial_revisions WHERE review_chain_id = ? "
+                "AND status = 'published' ORDER BY revision_number ASC",
+                (review_chain_id,),
+            )
+            return [dict(r) for r in await cur.fetchall()]
+
+    async def update_draft(self, revision_id: int, edited: domain.Snapshot,
+                           expected_version: int, *,
+                           editor_user_id: Optional[int] = None,
+                           editor_username: str = "",
+                           editor_display_name: str = "",
+                           severity: str = domain.MINOR) -> Optional[Dict[str, Any]]:
+        """CAS update of a DRAFT: rejects when ``version`` moved (409)."""
+        now = _stamp()
+        current = await self.get(revision_id)
+        if current is None:
+            raise EditorialNotFoundError("revision 不存在")
+        if current["status"] != domain.RevisionStatus.DRAFT.value:
+            raise EditorialStateError("只有草稿可以编辑")
+        if int(current["version"]) != int(expected_version):
+            raise EditorialConflictError("此投稿已被其他审核员更新，请刷新后继续编辑")
+        base = domain.Snapshot.from_dict(json.loads(current["base_snapshot"] or "{}"))
+        changes = domain.change_set(base, edited)
+        summary = "\n".join(domain.change_summary(changes))
+        severity = severity if severity in (domain.MINOR, domain.SUBSTANTIVE) else domain.MINOR
+        async with get_db() as conn:
+            cur = await conn.execute(
+                """
+                UPDATE editorial_revisions SET
+                  edited_snapshot = ?, change_set = ?, summary = ?,
+                  editor_user_id = ?, editor_username = ?, editor_display_name = ?,
+                  severity = ?, version = version + 1, updated_at = ?
+                WHERE id = ? AND version = ?
+                """,
+                (
+                    json.dumps(edited.to_dict(), ensure_ascii=False),
+                    json.dumps(changes, ensure_ascii=False),
+                    summary,
+                    editor_user_id, editor_username, editor_display_name,
+                    severity, now, int(revision_id), int(expected_version),
+                ),
+            )
+            if cur.rowcount != 1:
+                raise EditorialConflictError("此投稿已被其他审核员更新，请刷新后继续编辑")
+            return await self._select_in_conn(conn, int(revision_id))
+
+    async def finalize(self, revision_id: int, expected_version: int) -> Optional[Dict[str, Any]]:
+        """draft → finalized (only a finalized revision may be published, §30)."""
+        current = await self.get(revision_id)
+        if current is None:
+            raise EditorialNotFoundError("revision 不存在")
+        if int(current["version"]) != int(expected_version):
+            raise EditorialConflictError("此投稿已被其他审核员更新，请刷新后继续编辑")
+        if current["status"] not in (
+            domain.RevisionStatus.DRAFT.value, domain.RevisionStatus.FINALIZED.value
+        ):
+            raise EditorialStateError("该版本已发布或已作废，无法再次编辑发布")
+        now = _stamp()
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "UPDATE editorial_revisions SET status = 'finalized', "
+                "finalized_at = ?, updated_at = ?, version = version + 1 "
+                "WHERE id = ? AND version = ?",
+                (now, now, int(revision_id), int(expected_version)),
+            )
+            if cur.rowcount != 1:
+                raise EditorialConflictError("此投稿已被其他审核员更新，请刷新后继续编辑")
+            return await self._select_in_conn(conn, int(revision_id))
+
+    async def mark_published(self, revision_id: int, message_id: int,
+                             published_snapshot: Dict[str, object]) -> Optional[Dict[str, Any]]:
+        """finalized → published, with the immutable published snapshot (§32)."""
+        now = _stamp()
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "UPDATE editorial_revisions SET status = 'published', "
+                "published_message_id = ?, published_snapshot = ?, "
+                "published_at = ?, updated_at = ? "
+                "WHERE id = ? AND status = 'finalized'",
+                (
+                    int(message_id),
+                    json.dumps(published_snapshot, ensure_ascii=False),
+                    now, now, int(revision_id),
+                ),
+            )
+            if cur.rowcount != 1:
+                raise EditorialStateError("该版本状态已变化，无法标记发布")
+            return await self._select_in_conn(conn, int(revision_id))
+
+    async def supersede_for_review(self, review_id: int) -> int:
+        """Decide/expire/supersede a review: terminalize its open revisions so a
+        stale editor can never publish them (§35)."""
+        now = _stamp()
+        async with get_db() as conn:
+            cur = await conn.execute(
+                "UPDATE editorial_revisions SET status = 'superseded', "
+                "updated_at = ? WHERE review_id = ? AND status IN ('draft','finalized')",
+                (now, int(review_id)),
+            )
+            return cur.rowcount
+
+    async def _select_in_conn(self, conn: Any, revision_id: int) -> Dict[str, Any]:
+        cur = await conn.execute(
+            "SELECT * FROM editorial_revisions WHERE id = ?", (int(revision_id),)
+        )
+        row = await cur.fetchone()
+        if row is None:
+            raise EditorialNotFoundError("revision 不存在")
+        return dict(row)