| """SQLite manifest: the single source of truth for provenance and pipeline state. |
| |
| Tables |
| ------ |
| sources one row per (normalized) URL; download state |
| hits every (url, engine, query) that surfaced a URL -> class hints and provenance |
| harvest_runs completed (engine, query) harvests so reruns skip them |
| images one row per unique image (sha256 of original bytes) with all pipeline state |
| embeddings optional CLIP embeddings (float16 blobs) |
| |
| Image status flow |
| ----------------- |
| downloaded -> validated -> normalized -> deduped -> kept | review | discarded |
| Every stage only touches rows in its own input status, so all stages are idempotent |
| and a rerun after an interruption never repeats finished work. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| import sqlite3 |
| import threading |
| from contextlib import contextmanager |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any, Iterable, Iterator |
| from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit |
|
|
| import numpy as np |
|
|
| STATUSES = ("downloaded", "validated", "normalized", "deduped", "kept", "review", "discarded") |
|
|
| SCHEMA = """ |
| PRAGMA journal_mode=WAL; |
| PRAGMA synchronous=NORMAL; |
| |
| CREATE TABLE IF NOT EXISTS sources ( |
| url_norm TEXT PRIMARY KEY, |
| url TEXT NOT NULL, |
| status TEXT NOT NULL DEFAULT 'pending', |
| attempts INTEGER NOT NULL DEFAULT 0, |
| http_status INTEGER, |
| error TEXT, |
| image_id TEXT, |
| harvested_at TEXT, |
| downloaded_at TEXT |
| ); |
| CREATE INDEX IF NOT EXISTS idx_sources_status ON sources(status); |
| CREATE INDEX IF NOT EXISTS idx_sources_image ON sources(image_id); |
| |
| CREATE TABLE IF NOT EXISTS hits ( |
| url_norm TEXT NOT NULL, |
| engine TEXT NOT NULL, |
| query TEXT NOT NULL, |
| class_hint TEXT, |
| lang TEXT, |
| harvested_at TEXT, |
| PRIMARY KEY (url_norm, engine, query) |
| ); |
| |
| CREATE TABLE IF NOT EXISTS harvest_runs ( |
| engine TEXT NOT NULL, |
| query TEXT NOT NULL, |
| class_hint TEXT, |
| max_num INTEGER, |
| urls_found INTEGER, |
| urls_new INTEGER, |
| finished_at TEXT, |
| PRIMARY KEY (engine, query) |
| ); |
| |
| CREATE TABLE IF NOT EXISTS images ( |
| image_id TEXT PRIMARY KEY, |
| sha256 TEXT NOT NULL, |
| origin TEXT NOT NULL DEFAULT 'web', |
| source_ref TEXT, |
| orig_path TEXT, |
| orig_format TEXT, |
| filesize INTEGER, |
| width INTEGER, |
| height INTEGER, |
| aspect_ratio REAL, |
| norm_path TEXT, |
| norm_width INTEGER, |
| norm_height INTEGER, |
| pixel_sha256 TEXT, |
| phash TEXT, |
| dhash TEXT, |
| phash_flip TEXT, |
| dhash_flip TEXT, |
| flags TEXT NOT NULL DEFAULT '[]', |
| status TEXT NOT NULL, |
| discard_reason TEXT, |
| dup_of TEXT, |
| cluster_id TEXT, |
| clip_score REAL, |
| relevance_bucket TEXT, |
| board_type TEXT, |
| condition TEXT, |
| source_type TEXT, |
| review_status TEXT, |
| reviewer TEXT, |
| reviewed_at TEXT, |
| split TEXT, |
| session_id TEXT, |
| board_id TEXT, |
| created_at TEXT, |
| updated_at TEXT |
| ); |
| CREATE INDEX IF NOT EXISTS idx_images_status ON images(status); |
| CREATE INDEX IF NOT EXISTS idx_images_cluster ON images(cluster_id); |
| CREATE INDEX IF NOT EXISTS idx_images_dup_of ON images(dup_of); |
| |
| CREATE TABLE IF NOT EXISTS embeddings ( |
| image_id TEXT PRIMARY KEY, |
| dim INTEGER NOT NULL, |
| vec BLOB NOT NULL |
| ); |
| """ |
|
|
| IMAGE_COLUMNS = { |
| "image_id", "sha256", "origin", "source_ref", "orig_path", "orig_format", "filesize", "width", |
| "height", "aspect_ratio", "norm_path", "norm_width", "norm_height", "pixel_sha256", "phash", |
| "dhash", "phash_flip", "dhash_flip", "flags", "status", "discard_reason", "dup_of", "cluster_id", |
| "clip_score", "relevance_bucket", "board_type", "condition", "source_type", "review_status", |
| "reviewer", "reviewed_at", "split", "session_id", "board_id", "created_at", "updated_at", |
| } |
|
|
| _TRACKING_PARAMS = {"fbclid", "gclid", "msclkid", "yclid"} |
| _DEFAULT_PORTS = {"http": 80, "https": 443} |
|
|
|
|
| def utcnow() -> str: |
| return datetime.now(timezone.utc).isoformat(timespec="seconds") |
|
|
|
|
| def normalize_url(url: str) -> str: |
| """Canonical form used as the dedup key for URLs (case, default ports, fragment, tracking).""" |
| parts = urlsplit(url.strip()) |
| scheme = parts.scheme.lower() |
| host = (parts.hostname or "").lower() |
| try: |
| port = parts.port |
| except ValueError: |
| port = None |
| netloc = host |
| if port and port != _DEFAULT_PORTS.get(scheme): |
| netloc = f"{host}:{port}" |
| query = sorted( |
| (k, v) for k, v in parse_qsl(parts.query, keep_blank_values=True) |
| if not k.lower().startswith("utm_") and k.lower() not in _TRACKING_PARAMS |
| ) |
| return urlunsplit((scheme, netloc, parts.path or "/", urlencode(query), "")) |
|
|
|
|
| def _check_columns(fields: Iterable[str]) -> None: |
| bad = set(fields) - IMAGE_COLUMNS |
| if bad: |
| raise KeyError(f"unknown image column(s): {sorted(bad)}") |
|
|
|
|
| class Manifest: |
| """Thread-safe SQLite wrapper (one connection, serialized by an RLock).""" |
|
|
| def __init__(self, db_path: str | Path): |
| self.db_path = Path(db_path) |
| self.db_path.parent.mkdir(parents=True, exist_ok=True) |
| self._conn = sqlite3.connect(str(self.db_path), check_same_thread=False, |
| isolation_level=None, timeout=60) |
| self._conn.row_factory = sqlite3.Row |
| self._lock = threading.RLock() |
| self._tx_depth = 0 |
| with self._lock: |
| self._conn.executescript(SCHEMA) |
|
|
| |
| def close(self) -> None: |
| with self._lock: |
| self._conn.close() |
|
|
| def __enter__(self) -> "Manifest": |
| return self |
|
|
| def __exit__(self, *exc) -> None: |
| self.close() |
|
|
| @contextmanager |
| def transaction(self) -> Iterator[None]: |
| """Group many writes into one commit (re-entrant).""" |
| with self._lock: |
| outer = self._tx_depth == 0 |
| if outer: |
| self._conn.execute("BEGIN") |
| self._tx_depth += 1 |
| try: |
| yield |
| except BaseException: |
| self._tx_depth -= 1 |
| if outer: |
| self._conn.execute("ROLLBACK") |
| raise |
| else: |
| self._tx_depth -= 1 |
| if outer: |
| self._conn.execute("COMMIT") |
|
|
| def execute(self, sql: str, params: Iterable[Any] = ()) -> sqlite3.Cursor: |
| with self._lock: |
| return self._conn.execute(sql, tuple(params)) |
|
|
| def query(self, sql: str, params: Iterable[Any] = ()) -> list[sqlite3.Row]: |
| with self._lock: |
| return self._conn.execute(sql, tuple(params)).fetchall() |
|
|
| |
| def add_hit(self, url: str, engine: str, query: str, class_hint: str | None = None, |
| lang: str | None = None) -> bool: |
| """Record a harvested URL. Returns True if the URL was new.""" |
| url_norm = normalize_url(url) |
| now = utcnow() |
| with self._lock: |
| cur = self._conn.execute( |
| "INSERT OR IGNORE INTO sources(url_norm, url, status, harvested_at) " |
| "VALUES (?, ?, 'pending', ?)", (url_norm, url, now)) |
| is_new = cur.rowcount == 1 |
| self._conn.execute( |
| "INSERT OR IGNORE INTO hits(url_norm, engine, query, class_hint, lang, harvested_at) " |
| "VALUES (?, ?, ?, ?, ?, ?)", (url_norm, engine, query, class_hint, lang, now)) |
| return is_new |
|
|
| def pending_sources(self, limit: int | None = None, include_transient: bool = False) -> list[dict]: |
| statuses = ("pending", "failed_transient") if include_transient else ("pending",) |
| sql = f"SELECT * FROM sources WHERE status IN ({','.join('?' * len(statuses))}) ORDER BY harvested_at, url_norm" |
| params: list[Any] = list(statuses) |
| if limit: |
| sql += " LIMIT ?" |
| params.append(limit) |
| return [dict(r) for r in self.query(sql, params)] |
|
|
| def mark_source(self, url_norm: str, status: str, http_status: int | None = None, |
| error: str | None = None, image_id: str | None = None, attempts: int = 0) -> None: |
| self.execute( |
| "UPDATE sources SET status=?, http_status=?, error=?, image_id=?, " |
| "attempts=attempts+?, downloaded_at=? WHERE url_norm=?", |
| (status, http_status, error, image_id, attempts, utcnow(), url_norm)) |
|
|
| |
| def run_done(self, engine: str, query: str) -> bool: |
| return bool(self.query("SELECT 1 FROM harvest_runs WHERE engine=? AND query=?", (engine, query))) |
|
|
| def record_run(self, engine: str, query: str, class_hint: str | None, max_num: int, |
| found: int, new: int) -> None: |
| self.execute( |
| "INSERT OR REPLACE INTO harvest_runs VALUES (?, ?, ?, ?, ?, ?, ?)", |
| (engine, query, class_hint, max_num, found, new, utcnow())) |
|
|
| |
| def add_image(self, **fields: Any) -> bool: |
| """Insert an image row if its image_id is new. Returns True if inserted.""" |
| _check_columns(fields) |
| fields.setdefault("origin", "web") |
| now = utcnow() |
| fields.setdefault("created_at", now) |
| fields.setdefault("updated_at", now) |
| if isinstance(fields.get("flags"), (list, tuple, set)): |
| fields["flags"] = json.dumps(sorted(fields["flags"])) |
| cols = list(fields) |
| cur = self.execute( |
| f"INSERT OR IGNORE INTO images({','.join(cols)}) VALUES ({','.join('?' * len(cols))})", |
| [fields[c] for c in cols]) |
| return cur.rowcount == 1 |
|
|
| @staticmethod |
| def _row(row: sqlite3.Row | None) -> dict | None: |
| if row is None: |
| return None |
| d = dict(row) |
| d["flags"] = json.loads(d.get("flags") or "[]") |
| return d |
|
|
| def get_image(self, image_id: str) -> dict | None: |
| rows = self.query("SELECT * FROM images WHERE image_id=?", (image_id,)) |
| return self._row(rows[0]) if rows else None |
|
|
| def images(self, statuses: Iterable[str] | None = None, origin: str | None = None, |
| where: str | None = None, params: Iterable[Any] = ()) -> list[dict]: |
| clauses, args = [], [] |
| if statuses: |
| statuses = tuple(statuses) |
| clauses.append(f"status IN ({','.join('?' * len(statuses))})") |
| args += list(statuses) |
| if origin: |
| clauses.append("origin=?") |
| args.append(origin) |
| if where: |
| clauses.append(f"({where})") |
| args += list(params) |
| sql = "SELECT * FROM images" + (" WHERE " + " AND ".join(clauses) if clauses else "") |
| sql += " ORDER BY image_id" |
| return [self._row(r) for r in self.query(sql, args)] |
|
|
| def update_image(self, image_id: str, **fields: Any) -> None: |
| _check_columns(fields) |
| if not fields: |
| return |
| if isinstance(fields.get("flags"), (list, tuple, set)): |
| fields["flags"] = json.dumps(sorted(fields["flags"])) |
| fields["updated_at"] = utcnow() |
| sets = ", ".join(f"{c}=?" for c in fields) |
| self.execute(f"UPDATE images SET {sets} WHERE image_id=?", [*fields.values(), image_id]) |
|
|
| def add_flags(self, image_id: str, *new_flags: str) -> None: |
| img = self.get_image(image_id) |
| if img is None: |
| return |
| merged = sorted(set(img["flags"]) | set(new_flags)) |
| self.update_image(image_id, flags=merged) |
|
|
| def discard(self, image_id: str, reason: str, dup_of: str | None = None) -> None: |
| self.update_image(image_id, status="discarded", discard_reason=reason, dup_of=dup_of) |
|
|
| def count_by(self, column: str, where: str = "1=1", params: Iterable[Any] = ()) -> dict[str, int]: |
| _check_columns([column]) |
| rows = self.query( |
| f"SELECT {column} AS k, COUNT(*) AS n FROM images WHERE {where} GROUP BY {column}", params) |
| return {(r["k"] if r["k"] is not None else "none"): r["n"] for r in rows} |
|
|
| |
| def class_hints_by_image(self) -> dict[str, set[str]]: |
| """image_id -> class hints, folding duplicates (dup_of) into their keeper.""" |
| rows = self.query( |
| "SELECT s.image_id AS image_id, h.class_hint AS class_hint " |
| "FROM sources s JOIN hits h ON h.url_norm = s.url_norm " |
| "WHERE s.image_id IS NOT NULL AND h.class_hint IS NOT NULL") |
| direct: dict[str, set[str]] = {} |
| for r in rows: |
| direct.setdefault(r["image_id"], set()).add(r["class_hint"]) |
| result = {k: set(v) for k, v in direct.items()} |
| for r in self.query("SELECT image_id, dup_of FROM images WHERE dup_of IS NOT NULL"): |
| if r["image_id"] in direct: |
| result.setdefault(r["dup_of"], set()).update(direct[r["image_id"]]) |
| return result |
|
|
| def provenance(self, image_id: str) -> dict[str, list[str]]: |
| """Source URLs, queries, engines and class hints for an image incl. its duplicates.""" |
| rows = self.query( |
| "SELECT s.url AS url, h.engine AS engine, h.query AS query, h.class_hint AS class_hint " |
| "FROM sources s LEFT JOIN hits h ON h.url_norm = s.url_norm " |
| "WHERE s.image_id IN (SELECT ? UNION SELECT image_id FROM images WHERE dup_of = ?)", |
| (image_id, image_id)) |
| out: dict[str, set[str]] = {"source_urls": set(), "engines": set(), "queries": set(), |
| "class_hints": set()} |
| for r in rows: |
| out["source_urls"].add(r["url"]) |
| if r["engine"]: |
| out["engines"].add(r["engine"]) |
| if r["query"]: |
| out["queries"].add(r["query"]) |
| if r["class_hint"]: |
| out["class_hints"].add(r["class_hint"]) |
| return {k: sorted(v) for k, v in out.items()} |
|
|
| def valid_counts_by_class(self, valid_statuses: Iterable[str] = ("deduped", "kept", "validated", "normalized")) -> dict[str, int]: |
| """Return a mapping of class_hint -> count of valid (non-discarded) images.""" |
| statuses = tuple(valid_statuses) |
| sql = f""" |
| SELECT h.class_hint, COUNT(DISTINCT i.image_id) |
| FROM images i |
| JOIN sources s ON i.source_ref = s.url_norm OR i.image_id = s.image_id |
| JOIN hits h ON s.url_norm = h.url_norm |
| WHERE i.status IN ({','.join('?' * len(statuses))}) |
| GROUP BY h.class_hint |
| """ |
| rows = self.query(sql, statuses) |
| return {r[0]: r[1] for r in rows if r[0]} |
|
|
| def export_jsonl(self, path: str | Path) -> int: |
| path = Path(path) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| n = 0 |
| with open(path, "w", encoding="utf-8") as fh: |
| for img in self.images(): |
| img.update(self.provenance(img["image_id"])) |
| fh.write(json.dumps(img, ensure_ascii=False) + "\n") |
| n += 1 |
| return n |
|
|
| |
| def save_embeddings(self, vectors: dict[str, np.ndarray]) -> None: |
| with self.transaction(): |
| for image_id, vec in vectors.items(): |
| arr = np.asarray(vec, dtype=np.float16) |
| self.execute("INSERT OR REPLACE INTO embeddings VALUES (?, ?, ?)", |
| (image_id, int(arr.shape[0]), arr.tobytes())) |
|
|
| def load_embeddings(self, image_ids: Iterable[str] | None = None) -> tuple[list[str], np.ndarray]: |
| rows = self.query("SELECT image_id, dim, vec FROM embeddings ORDER BY image_id") |
| if image_ids is not None: |
| wanted = set(image_ids) |
| rows = [r for r in rows if r["image_id"] in wanted] |
| if not rows: |
| return [], np.zeros((0, 0), dtype=np.float32) |
| ids = [r["image_id"] for r in rows] |
| mat = np.stack([np.frombuffer(r["vec"], dtype=np.float16).astype(np.float32) for r in rows]) |
| return ids, mat |
|
|
