deepresearch-flow 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

deepresearch_flow/paper/snapshot/identity.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import difflib
+import hashlib
+import json
+import re
+import unicodedata
+from typing import Any
+from urllib.parse import unquote
+
+
+_DOI_PREFIX_RE = re.compile(r"^(?:https?://(?:dx\.)?doi\.org/|doi:\s*)", re.IGNORECASE)
+_ARXIV_PREFIX_RE = re.compile(r"^(?:https?://arxiv\.org/abs/|arxiv:\s*)", re.IGNORECASE)
+_ARXIV_VERSION_RE = re.compile(r"v\d+$", re.IGNORECASE)
+_YEAR_RE = re.compile(r"(19|20)\d{2}")
+
+
+def canonicalize_doi(raw: str | None) -> str | None:
+    if not raw:
+        return None
+    value = unquote(str(raw).strip())
+    if not value:
+        return None
+    value = _DOI_PREFIX_RE.sub("", value).strip().lower()
+    value = value.rstrip()
+    value = value.rstrip(".,;)")
+    return value or None
+
+
+def canonicalize_arxiv(raw: str | None) -> str | None:
+    if not raw:
+        return None
+    value = str(raw).strip()
+    if not value:
+        return None
+    value = _ARXIV_PREFIX_RE.sub("", value).strip().lower()
+    value = _ARXIV_VERSION_RE.sub("", value)
+    return value or None
+
+
+def _collapse_ws(text: str) -> str:
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _strip_punct_symbols(text: str) -> str:
+    out: list[str] = []
+    for ch in text:
+        cat = unicodedata.category(ch)
+        if cat and cat[0] in {"P", "S"}:
+            out.append(" ")
+        else:
+            out.append(ch)
+    return "".join(out)
+
+
+def normalize_meta_title(raw: str | None) -> str:
+    if not raw:
+        return ""
+    text = unicodedata.normalize("NFKC", str(raw)).lower()
+    text = _strip_punct_symbols(text)
+    return _collapse_ws(text)
+
+
+def normalize_meta_name(raw: str | None) -> str:
+    if not raw:
+        return ""
+    text = unicodedata.normalize("NFKC", str(raw)).lower()
+    return _collapse_ws(text)
+
+
+def normalize_meta_venue(raw: str | None) -> str:
+    if not raw:
+        return ""
+    text = unicodedata.normalize("NFKC", str(raw)).lower()
+    return _collapse_ws(text)
+
+
+def extract_year(value: str | None) -> str | None:
+    if not value:
+        return None
+    match = _YEAR_RE.search(str(value))
+    return match.group(0) if match else None
+
+
+def normalized_authors(raw: Any) -> list[str]:
+    if raw is None:
+        return []
+    if isinstance(raw, list):
+        items = [normalize_meta_name(item) for item in raw]
+        return sorted([item for item in items if item])
+    if isinstance(raw, str):
+        parts = [normalize_meta_name(part) for part in raw.split(",")]
+        return sorted([part for part in parts if part])
+    value = normalize_meta_name(str(raw))
+    return [value] if value else []
+
+
+def meta_fingerprint_json(*, title: str, authors: list[str], year: str, venue: str) -> str:
+    payload = {"title": title, "authors": authors, "year": year, "venue": venue}
+    return json.dumps(payload, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
+
+
+def meta_hash(*, title: str, authors: list[str], year: str, venue: str) -> str:
+    payload = meta_fingerprint_json(title=title, authors=authors, year=year, venue=venue)
+    return hashlib.sha256(payload.encode("utf-8", errors="ignore")).hexdigest()
+
+
+def paper_id_for_key(paper_key: str) -> str:
+    digest = hashlib.sha256(f"v1|{paper_key}".encode("utf-8", errors="ignore")).hexdigest()
+    return digest[:32]
+
+
+@dataclass(frozen=True)
+class PaperKeyCandidate:
+    key_type: str  # doi|arxiv|bib|meta
+    paper_key: str
+    meta_fingerprint: str | None = None
+
+    @property
+    def strength(self) -> int:
+        order = {"doi": 4, "arxiv": 3, "bib": 2, "meta": 1}
+        return order.get(self.key_type, 0)
+
+
+def _bib_fields_lower(paper: dict[str, Any]) -> dict[str, str]:
+    bib = paper.get("bibtex")
+    if not isinstance(bib, dict):
+        return {}
+    fields = bib.get("fields")
+    if not isinstance(fields, dict):
+        return {}
+    out: dict[str, str] = {}
+    for key, value in fields.items():
+        if value is None:
+            continue
+        out[str(key).lower()] = str(value)
+    return out
+
+
+def _extract_doi(paper: dict[str, Any]) -> str | None:
+    if isinstance(paper.get("doi"), str):
+        return paper.get("doi")
+    if isinstance(paper.get("paper_doi"), str):
+        return paper.get("paper_doi")
+    fields = _bib_fields_lower(paper)
+    return fields.get("doi")
+
+
+def _extract_arxiv(paper: dict[str, Any]) -> str | None:
+    fields = _bib_fields_lower(paper)
+    for key in ("arxiv", "arxivid", "arxiv_id", "arxiv-id"):
+        if key in fields:
+            return fields[key]
+    archive_prefix = (fields.get("archiveprefix") or fields.get("archive_prefix") or "").strip().lower()
+    if archive_prefix == "arxiv" and fields.get("eprint"):
+        return fields.get("eprint")
+    if isinstance(paper.get("arxiv"), str):
+        return paper.get("arxiv")
+    if isinstance(paper.get("arxiv_id"), str):
+        return paper.get("arxiv_id")
+    return None
+
+
+def _extract_bib_key(paper: dict[str, Any]) -> str | None:
+    bib = paper.get("bibtex")
+    if not isinstance(bib, dict):
+        return None
+    key = bib.get("key")
+    if isinstance(key, str) and key.strip():
+        return key.strip()
+    return None
+
+
+def build_paper_key_candidates(paper: dict[str, Any]) -> list[PaperKeyCandidate]:
+    candidates: list[PaperKeyCandidate] = []
+
+    doi = canonicalize_doi(_extract_doi(paper))
+    if doi:
+        candidates.append(PaperKeyCandidate(key_type="doi", paper_key=f"doi:{doi}"))
+
+    arxiv = canonicalize_arxiv(_extract_arxiv(paper))
+    if arxiv:
+        candidates.append(PaperKeyCandidate(key_type="arxiv", paper_key=f"arxiv:{arxiv}"))
+
+    bib_key = _extract_bib_key(paper)
+    if bib_key:
+        candidates.append(PaperKeyCandidate(key_type="bib", paper_key=f"bib:{bib_key}"))
+
+    title = normalize_meta_title(str(paper.get("paper_title") or ""))
+    authors = normalized_authors(paper.get("paper_authors"))
+    year = (
+        extract_year(str(_bib_fields_lower(paper).get("year") or "")) or extract_year(str(paper.get("publication_date") or "")) or "unknown"
+    )
+    venue_raw = _bib_fields_lower(paper).get("journal") or _bib_fields_lower(paper).get("booktitle") or str(paper.get("publication_venue") or "")
+    venue = normalize_meta_venue(venue_raw)
+    fingerprint = meta_fingerprint_json(title=title, authors=authors, year=year, venue=venue)
+    candidates.append(
+        PaperKeyCandidate(
+            key_type="meta",
+            paper_key=f"meta:{meta_hash(title=title, authors=authors, year=year, venue=venue)}",
+            meta_fingerprint=fingerprint,
+        )
+    )
+
+    return candidates
+
+
+def choose_preferred_key(candidates: list[PaperKeyCandidate]) -> PaperKeyCandidate:
+    if not candidates:
+        raise ValueError("At least one candidate key is required")
+    return max(candidates, key=lambda item: item.strength)
+
+
+def meta_fingerprint_divergent(
+    previous_fingerprint: str | None,
+    current_fingerprint: str | None,
+    *,
+    min_title_similarity: float,
+    min_author_jaccard: float,
+) -> bool:
+    if not previous_fingerprint or not current_fingerprint:
+        return False
+    try:
+        prev = json.loads(previous_fingerprint)
+        cur = json.loads(current_fingerprint)
+    except Exception:
+        return True
+    prev_title = str(prev.get("title") or "")
+    cur_title = str(cur.get("title") or "")
+    title_similarity = difflib.SequenceMatcher(a=prev_title, b=cur_title).ratio()
+
+    prev_authors = {str(item) for item in (prev.get("authors") or []) if str(item)}
+    cur_authors = {str(item) for item in (cur.get("authors") or []) if str(item)}
+    union = prev_authors | cur_authors
+    jaccard = (len(prev_authors & cur_authors) / len(union)) if union else 1.0
+
+    return title_similarity < min_title_similarity and jaccard < min_author_jaccard
+

deepresearch_flow/paper/snapshot/schema.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import sqlite3
+
+
+def init_snapshot_db(conn: sqlite3.Connection) -> None:
+    conn.execute("PRAGMA foreign_keys=ON;")
+    conn.execute("PRAGMA journal_mode=WAL;")
+
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS snapshot_meta (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS paper (
+          paper_id TEXT PRIMARY KEY,
+          paper_key TEXT NOT NULL,
+          paper_key_type TEXT NOT NULL,
+          title TEXT NOT NULL,
+          year TEXT NOT NULL,
+          month TEXT NOT NULL,
+          publication_date TEXT NOT NULL,
+          venue TEXT NOT NULL,
+          preferred_summary_template TEXT NOT NULL,
+          summary_preview TEXT NOT NULL,
+          paper_index INTEGER NOT NULL DEFAULT 0,
+          source_hash TEXT,
+          output_language TEXT,
+          provider TEXT,
+          model TEXT,
+          prompt_template TEXT,
+          extracted_at TEXT,
+          pdf_content_hash TEXT,
+          source_md_content_hash TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS paper_summary (
+          paper_id TEXT NOT NULL,
+          template_tag TEXT NOT NULL,
+          PRIMARY KEY (paper_id, template_tag),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_summary_template ON paper_summary(template_tag);
+
+        CREATE TABLE IF NOT EXISTS paper_translation (
+          paper_id TEXT NOT NULL,
+          lang TEXT NOT NULL,
+          md_content_hash TEXT NOT NULL,
+          PRIMARY KEY (paper_id, lang),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE
+        );
+
+        CREATE TABLE IF NOT EXISTS paper_key_alias (
+          paper_key TEXT PRIMARY KEY,
+          paper_id TEXT NOT NULL,
+          paper_key_type TEXT NOT NULL,
+          meta_fingerprint TEXT,
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_key_alias_paper_id ON paper_key_alias(paper_id);
+
+        CREATE TABLE IF NOT EXISTS author (
+          author_id INTEGER PRIMARY KEY,
+          value TEXT NOT NULL UNIQUE,
+          paper_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE TABLE IF NOT EXISTS paper_author (
+          paper_id TEXT NOT NULL,
+          author_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, author_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (author_id) REFERENCES author(author_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_author_author_id ON paper_author(author_id);
+
+        CREATE TABLE IF NOT EXISTS keyword (
+          keyword_id INTEGER PRIMARY KEY,
+          value TEXT NOT NULL UNIQUE,
+          paper_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE TABLE IF NOT EXISTS paper_keyword (
+          paper_id TEXT NOT NULL,
+          keyword_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, keyword_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (keyword_id) REFERENCES keyword(keyword_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_keyword_keyword_id ON paper_keyword(keyword_id);
+
+        CREATE TABLE IF NOT EXISTS institution (
+          institution_id INTEGER PRIMARY KEY,
+          value TEXT NOT NULL UNIQUE,
+          paper_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE TABLE IF NOT EXISTS paper_institution (
+          paper_id TEXT NOT NULL,
+          institution_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, institution_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (institution_id) REFERENCES institution(institution_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_institution_institution_id ON paper_institution(institution_id);
+
+        CREATE TABLE IF NOT EXISTS tag (
+          tag_id INTEGER PRIMARY KEY,
+          value TEXT NOT NULL UNIQUE,
+          paper_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE TABLE IF NOT EXISTS paper_tag (
+          paper_id TEXT NOT NULL,
+          tag_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, tag_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (tag_id) REFERENCES tag(tag_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_tag_tag_id ON paper_tag(tag_id);
+
+        CREATE TABLE IF NOT EXISTS venue (
+          venue_id INTEGER PRIMARY KEY,
+          value TEXT NOT NULL UNIQUE,
+          paper_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE TABLE IF NOT EXISTS paper_venue (
+          paper_id TEXT NOT NULL,
+          venue_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, venue_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (venue_id) REFERENCES venue(venue_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_venue_venue_id ON paper_venue(venue_id);
+
+        CREATE TABLE IF NOT EXISTS facet_node (
+          node_id INTEGER PRIMARY KEY,
+          facet_type TEXT NOT NULL,
+          value TEXT NOT NULL,
+          paper_count INTEGER NOT NULL DEFAULT 0,
+          UNIQUE(facet_type, value)
+        );
+        CREATE INDEX IF NOT EXISTS idx_facet_node_type ON facet_node(facet_type);
+        CREATE INDEX IF NOT EXISTS idx_facet_node_value ON facet_node(value);
+
+        CREATE TABLE IF NOT EXISTS paper_facet (
+          paper_id TEXT NOT NULL,
+          node_id INTEGER NOT NULL,
+          PRIMARY KEY (paper_id, node_id),
+          FOREIGN KEY (paper_id) REFERENCES paper(paper_id) ON DELETE CASCADE,
+          FOREIGN KEY (node_id) REFERENCES facet_node(node_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_paper_facet_node_id ON paper_facet(node_id);
+
+        CREATE TABLE IF NOT EXISTS facet_edge (
+          node_id_a INTEGER NOT NULL,
+          node_id_b INTEGER NOT NULL,
+          paper_count INTEGER NOT NULL DEFAULT 0,
+          PRIMARY KEY (node_id_a, node_id_b),
+          FOREIGN KEY (node_id_a) REFERENCES facet_node(node_id) ON DELETE CASCADE,
+          FOREIGN KEY (node_id_b) REFERENCES facet_node(node_id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_facet_edge_a ON facet_edge(node_id_a);
+        CREATE INDEX IF NOT EXISTS idx_facet_edge_b ON facet_edge(node_id_b);
+
+        CREATE TABLE IF NOT EXISTS year_count (
+          year TEXT PRIMARY KEY,
+          paper_count INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS month_count (
+          month TEXT PRIMARY KEY,
+          paper_count INTEGER NOT NULL
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS paper_fts USING fts5(
+          paper_id UNINDEXED,
+          title,
+          summary,
+          source,
+          translated,
+          metadata,
+          tokenize='unicode61'
+        );
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS paper_fts_trigram USING fts5(
+          paper_id UNINDEXED,
+          title,
+          venue,
+          tokenize='trigram'
+        );
+        """
+    )
+
+
+def recompute_facet_counts(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        "UPDATE author SET paper_count = (SELECT COUNT(*) FROM paper_author WHERE author_id = author.author_id);"
+    )
+    conn.execute(
+        "UPDATE keyword SET paper_count = (SELECT COUNT(*) FROM paper_keyword WHERE keyword_id = keyword.keyword_id);"
+    )
+    conn.execute(
+        "UPDATE institution SET paper_count = (SELECT COUNT(*) FROM paper_institution WHERE institution_id = institution.institution_id);"
+    )
+    conn.execute(
+        "UPDATE tag SET paper_count = (SELECT COUNT(*) FROM paper_tag WHERE tag_id = tag.tag_id);"
+    )
+    conn.execute(
+        "UPDATE venue SET paper_count = (SELECT COUNT(*) FROM paper_venue WHERE venue_id = venue.venue_id);"
+    )
+    conn.execute(
+        "UPDATE facet_node SET paper_count = (SELECT COUNT(*) FROM paper_facet WHERE node_id = facet_node.node_id);"
+    )
+
+    conn.execute("DELETE FROM year_count;")
+    conn.execute(
+        """
+        INSERT INTO year_count(year, paper_count)
+        SELECT year, COUNT(*) AS paper_count
+        FROM paper
+        GROUP BY year
+        """
+    )
+
+    conn.execute("DELETE FROM month_count;")
+    conn.execute(
+        """
+        INSERT INTO month_count(month, paper_count)
+        SELECT month, COUNT(*) AS paper_count
+        FROM paper
+        GROUP BY month
+        """
+    )
+
+
+def recompute_paper_index(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        """
+        WITH ordered AS (
+          SELECT paper_id, ROW_NUMBER() OVER (ORDER BY paper_id ASC) AS idx
+          FROM paper
+        )
+        UPDATE paper
+        SET paper_index = (SELECT idx FROM ordered WHERE ordered.paper_id = paper.paper_id);
+        """
+    )

deepresearch_flow/paper/snapshot/tests/__init__.py

@@ -0,0 +1,2 @@
+"""Unit tests for snapshot build + API helpers."""
+

deepresearch_flow/paper/snapshot/tests/test_identity.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import unittest
+
+from deepresearch_flow.paper.snapshot.identity import (
+    canonicalize_arxiv,
+    canonicalize_doi,
+    meta_fingerprint_divergent,
+    paper_id_for_key,
+)
+from deepresearch_flow.paper.snapshot.text import (
+    insert_cjk_spaces,
+    markdown_to_plain_text,
+    merge_adjacent_markers,
+    remove_cjk_spaces,
+    rewrite_search_query,
+)
+
+
+class TestIdentity(unittest.TestCase):
+    def test_canonicalize_doi_prefix_decode_and_case(self) -> None:
+        self.assertEqual(
+            canonicalize_doi("https://doi.org/10.1000%2FXYZ."),
+            "10.1000/xyz",
+        )
+
+    def test_canonicalize_arxiv_strips_version(self) -> None:
+        self.assertEqual(
+            canonicalize_arxiv("https://arxiv.org/abs/2301.00001v3"),
+            "2301.00001",
+        )
+
+    def test_paper_id_is_stable(self) -> None:
+        key = "doi:10.1000/xyz"
+        self.assertEqual(paper_id_for_key(key), paper_id_for_key(key))
+
+    def test_meta_fingerprint_divergence_requires_both_signals(self) -> None:
+        prev = '{"authors":["a","b"],"title":"deep learning","venue":"x","year":"2020"}'
+        cur = '{"authors":["c"],"title":"completely different","venue":"y","year":"2020"}'
+        self.assertTrue(
+            meta_fingerprint_divergent(
+                prev,
+                cur,
+                min_title_similarity=0.8,
+                min_author_jaccard=0.5,
+            )
+        )
+        cur_same_authors = '{"authors":["a","b"],"title":"completely different","venue":"y","year":"2020"}'
+        self.assertFalse(
+            meta_fingerprint_divergent(
+                prev,
+                cur_same_authors,
+                min_title_similarity=0.8,
+                min_author_jaccard=0.5,
+            )
+        )
+
+
+class TestSearchText(unittest.TestCase):
+    def test_rewrite_search_query_cjk_phrase(self) -> None:
+        self.assertEqual(rewrite_search_query("深度学习"), "\"深 度 学 习\"")
+
+    def test_rewrite_search_query_mixed(self) -> None:
+        self.assertEqual(rewrite_search_query("深度学习 transformer"), "\"深 度 学 习\" transformer")
+
+    def test_rewrite_search_query_boolean(self) -> None:
+        self.assertEqual(rewrite_search_query("lidar AND localization"), "lidar AND localization")
+
+    def test_markdown_to_plain_text_strips_tables(self) -> None:
+        md = "hello\n\n| a | b |\n|---|---|\n| 1 | 2 |\n\nworld"
+        plain = markdown_to_plain_text(md)
+        self.assertIn("hello", plain)
+        self.assertIn("world", plain)
+        self.assertNotIn("1", plain)
+        self.assertNotIn("2", plain)
+
+    def test_cjk_spacing_roundtrip(self) -> None:
+        original = "深度学习"
+        spaced = insert_cjk_spaces(original)
+        self.assertEqual(spaced, "深 度 学 习")
+        self.assertEqual(remove_cjk_spaces(spaced), original)
+
+    def test_merge_adjacent_markers(self) -> None:
+        self.assertEqual(
+            merge_adjacent_markers("[[[深]]][[[度]]]"),
+            "[[[深度]]]",
+        )
+
+    def test_markdown_monthly_facets_exist_after_build(self) -> None:
+        # This is a lightweight schema sanity check (no full build here).
+        # The snapshot DB is expected to include month support via schema tables.
+        import sqlite3
+        from deepresearch_flow.paper.snapshot.schema import init_snapshot_db
+
+        conn = sqlite3.connect(":memory:")
+        try:
+            init_snapshot_db(conn)
+            tables = {row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+            self.assertIn("month_count", tables)
+            cols = {row[1] for row in conn.execute("PRAGMA table_info(paper)")}
+            self.assertIn("month", cols)
+            self.assertIn("publication_date", cols)
+        finally:
+            conn.close()
+
+    def test_extract_template_summaries(self) -> None:
+        from deepresearch_flow.paper.snapshot.builder import _extract_template_summaries, _choose_preferred_summary_template
+
+        paper = {
+            "templates": {
+                "simple": {"summary": "s1"},
+                "deep_read": {"summary": "s2"},
+            },
+            "prompt_template": "deep_read",
+        }
+        summaries = _extract_template_summaries(paper)
+        self.assertEqual(summaries["simple"], "s1")
+        self.assertEqual(summaries["deep_read"], "s2")
+        self.assertEqual(_choose_preferred_summary_template(paper, summaries), "deep_read")
+
+
+if __name__ == "__main__":
+    unittest.main()