518 lines
19 KiB
Python
518 lines
19 KiB
Python
from citegeist import BibliographyStore
|
|
from citegeist.bootstrap import Bootstrapper
|
|
from citegeist.cli import main
|
|
from citegeist.expand import ExpansionResult
|
|
|
|
|
|
def test_bootstrap_from_seed_bib_only():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
seed_bibtex="""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
""",
|
|
expand=False,
|
|
)
|
|
|
|
assert [item.citation_key for item in results] == ["seed2024"]
|
|
assert store.get_entry("seed2024") is not None
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_from_topic_only():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
__import__("citegeist").BibEntry(
|
|
entry_type="article",
|
|
citation_key="topic2024graph",
|
|
fields={"title": "Graph Topic Result", "year": "2024"},
|
|
)
|
|
]
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(store, topic="graph topic", expand=False)
|
|
|
|
assert [item.citation_key for item in results] == ["topic2024graph"]
|
|
assert store.get_entry("topic2024graph") is not None
|
|
assert results[0].score > 0
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_cli_accepts_seed_and_topic(tmp_path):
|
|
seed_bib = tmp_path / "seed.bib"
|
|
seed_bib.write_text(
|
|
"""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
from unittest.mock import patch
|
|
|
|
database = tmp_path / "library.sqlite3"
|
|
with patch("citegeist.cli.Bootstrapper.bootstrap") as mocked_bootstrap:
|
|
mocked_bootstrap.return_value = []
|
|
exit_code = main(
|
|
[
|
|
"--db",
|
|
str(database),
|
|
"bootstrap",
|
|
"--seed-bib",
|
|
str(seed_bib),
|
|
"--topic",
|
|
"graph topic",
|
|
"--no-expand",
|
|
]
|
|
)
|
|
|
|
assert exit_code == 0
|
|
|
|
|
|
def test_bootstrap_cli_preview_outputs_candidate_metadata(tmp_path, capsys):
|
|
from unittest.mock import patch
|
|
from citegeist.bootstrap import BootstrapResult
|
|
|
|
database = tmp_path / "library.sqlite3"
|
|
with patch("citegeist.cli.Bootstrapper.bootstrap") as mocked_bootstrap:
|
|
mocked_bootstrap.return_value = [
|
|
BootstrapResult(
|
|
citation_key="openalexw123",
|
|
origin="topic",
|
|
created=True,
|
|
score=4.0,
|
|
title="Artificial Life and Adaptive Behavior",
|
|
author="Langton, Christopher G.",
|
|
year="1989",
|
|
abstract="A foundational overview of artificial life systems.",
|
|
)
|
|
]
|
|
exit_code = main(
|
|
[
|
|
"--db",
|
|
str(database),
|
|
"bootstrap",
|
|
"--topic",
|
|
"artificial life",
|
|
"--preview",
|
|
"--topic-commit-limit",
|
|
"50",
|
|
]
|
|
)
|
|
|
|
assert exit_code == 0
|
|
payload = capsys.readouterr().out
|
|
assert "Artificial Life and Adaptive Behavior" in payload
|
|
assert "Langton, Christopher G." in payload
|
|
assert "A foundational overview of artificial life systems." in payload
|
|
|
|
|
|
def test_bootstrap_ranks_and_deduplicates_topic_candidates():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="shared2024graph",
|
|
fields={"title": "Graph Topic Ranking", "abstract": "graph topic graph"},
|
|
)
|
|
]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="shared2024graph",
|
|
fields={"title": "Graph Topic Ranking", "abstract": "graph"},
|
|
),
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="crossref2024other",
|
|
fields={"title": "Less relevant paper"},
|
|
),
|
|
]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(store, topic="graph topic", expand=False, topic_limit=5)
|
|
|
|
topic_results = [item for item in results if item.origin == "topic"]
|
|
assert [item.citation_key for item in topic_results] == ["shared2024graph"]
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_preview_does_not_write_to_database():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(entry_type="article", citation_key="preview2024graph", fields={"title": "Preview Graph Topic"})
|
|
]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(store, topic="graph topic", expand=False, preview_only=True)
|
|
|
|
assert [item.citation_key for item in results] == ["preview2024graph"]
|
|
assert results[0].title == "Preview Graph Topic"
|
|
assert store.get_entry("preview2024graph") is None
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_topic_commit_limit_restricts_persisted_candidates():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(entry_type="article", citation_key="rank1", fields={"title": "Graph Topic One"}),
|
|
BibEntry(entry_type="article", citation_key="rank2", fields={"title": "Graph Topic Two"}),
|
|
]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
topic="graph topic",
|
|
expand=False,
|
|
topic_limit=5,
|
|
topic_commit_limit=1,
|
|
)
|
|
|
|
assert [item.citation_key for item in results if item.origin == "topic"] == ["rank1"]
|
|
assert store.get_entry("rank1") is not None
|
|
assert store.get_entry("rank2") is None
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_topic_candidates_are_attached_to_topic():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="topic2024graph",
|
|
fields={"title": "Graph Topic Result", "year": "2024"},
|
|
)
|
|
]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
bootstrapper.bootstrap(
|
|
store,
|
|
topic="graph topic",
|
|
topic_slug="graph-topic",
|
|
topic_name="Graph Topic",
|
|
topic_phrase="graph topic methods",
|
|
expand=False,
|
|
topic_commit_limit=1,
|
|
)
|
|
|
|
topic = store.get_topic("graph-topic")
|
|
assert topic is not None
|
|
assert topic["entry_count"] == 1
|
|
topic_entries = store.list_topic_entries("graph-topic")
|
|
assert [item["citation_key"] for item in topic_entries] == ["topic2024graph"]
|
|
assert topic_entries[0]["source_label"] == "topic:graph topic"
|
|
assert topic_entries[0]["confidence"] > 0
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_topic_commit_requires_title_anchor():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="broad2024",
|
|
fields={
|
|
"title": "The phylum Vertebrata: a case for zoological recognition",
|
|
"abstract": "Chordata includes Cephalochordata and Urochordata.",
|
|
"year": "2024",
|
|
},
|
|
),
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key="anchored2024",
|
|
fields={
|
|
"title": "Acraniates and amphioxus in comparative development",
|
|
"year": "2024",
|
|
},
|
|
),
|
|
]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, _key: [] # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, _key, relation_type="cites", limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
topic="acraniates cephalochordata amphioxus lancelet",
|
|
topic_slug="acraniates",
|
|
topic_name="Acraniates",
|
|
expand=False,
|
|
topic_commit_limit=5,
|
|
)
|
|
|
|
assert [item.citation_key for item in results] == ["anchored2024"]
|
|
topic_entries = store.list_topic_entries("acraniates")
|
|
assert [item["citation_key"] for item in topic_entries] == ["anchored2024"]
|
|
assert store.get_entry("broad2024") is None
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_nonlegacy_both_mode_expands_both_relations():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
calls: list[tuple[str, str, int]] = []
|
|
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, key, relation_type="cites", limit=5: ( # type: ignore[method-assign]
|
|
calls.append((key, relation_type, limit)) or []
|
|
)
|
|
|
|
bootstrapper.bootstrap(
|
|
store,
|
|
seed_bibtex="""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
""",
|
|
expansion_mode="both",
|
|
expand=True,
|
|
)
|
|
|
|
assert calls == [("seed2024", "cites", 5), ("seed2024", "cited_by", 5)]
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_recent_target_stops_recursive_openalex_expansion():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
store.upsert_entry(
|
|
BibEntry(entry_type="article", citation_key="recent2026", fields={"title": "Recent discovery", "year": "2026"}),
|
|
source_type="graph_expand",
|
|
source_label="test",
|
|
review_status="draft",
|
|
)
|
|
store.connection.commit()
|
|
|
|
def fake_expand(_store, key, relation_type="cites", limit=5):
|
|
if key == "seed2024":
|
|
return [
|
|
ExpansionResult(
|
|
"seed2024",
|
|
"recent2026",
|
|
False,
|
|
relation_type,
|
|
f"openalex:{relation_type}:seed2024",
|
|
)
|
|
]
|
|
return []
|
|
|
|
bootstrapper.openalex_expander.expand_entry = fake_expand # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
seed_bibtex="""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
""",
|
|
expansion_mode="cites",
|
|
expansion_rounds=3,
|
|
recent_years=2,
|
|
target_recent_entries=1,
|
|
expand=True,
|
|
)
|
|
|
|
assert [item.origin for item in results][-1] == "openalex_expand:cites"
|
|
assert [item.citation_key for item in results if item.origin.startswith("openalex_expand")] == ["recent2026"]
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_max_expanded_entries_caps_growth():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
store.upsert_entry(
|
|
BibEntry(entry_type="article", citation_key="d1", fields={"title": "Discovery One", "year": "2024"}),
|
|
source_type="graph_expand",
|
|
source_label="test",
|
|
review_status="draft",
|
|
)
|
|
store.upsert_entry(
|
|
BibEntry(entry_type="article", citation_key="d2", fields={"title": "Discovery Two", "year": "2024"}),
|
|
source_type="graph_expand",
|
|
source_label="test",
|
|
review_status="draft",
|
|
)
|
|
store.connection.commit()
|
|
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, key, relation_type="cites", limit=5: ( # type: ignore[method-assign]
|
|
[
|
|
ExpansionResult(key, "d1", False, relation_type, f"openalex:{relation_type}:{key}"),
|
|
ExpansionResult(key, "d2", False, relation_type, f"openalex:{relation_type}:{key}"),
|
|
]
|
|
if key == "seed2024"
|
|
else []
|
|
)
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
seed_bibtex="""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
""",
|
|
expansion_mode="cites",
|
|
expand=True,
|
|
max_expanded_entries=1,
|
|
)
|
|
|
|
assert [item.citation_key for item in results if item.origin.startswith("openalex_expand")] == ["d1"]
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_max_expand_seconds_stops_legacy_expansion(monkeypatch):
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
ticks = iter([0.0, 0.0, 2.0, 2.0, 2.0])
|
|
monkeypatch.setattr("citegeist.bootstrap.time.monotonic", lambda: next(ticks))
|
|
calls: list[str] = []
|
|
|
|
bootstrapper.crossref_expander.expand_entry_references = lambda _store, key: (calls.append(f"crossref:{key}") or []) # type: ignore[method-assign]
|
|
bootstrapper.openalex_expander.expand_entry = lambda _store, key, relation_type="cites", limit=5: (calls.append(f"openalex:{key}") or []) # type: ignore[method-assign]
|
|
|
|
bootstrapper.bootstrap(
|
|
store,
|
|
seed_bibtex="""
|
|
@article{seed2024,
|
|
author = {Seed, Alice},
|
|
title = {Seed Paper},
|
|
year = {2024}
|
|
}
|
|
|
|
@article{seed2023,
|
|
author = {Seed, Bob},
|
|
title = {Older Seed},
|
|
year = {2023}
|
|
}
|
|
""",
|
|
expansion_mode="legacy",
|
|
expand=True,
|
|
max_expand_seconds=1.0,
|
|
)
|
|
|
|
assert len(calls) <= 2
|
|
finally:
|
|
store.close()
|
|
|
|
|
|
def test_bootstrap_preview_uses_topic_commit_limit_when_larger_than_topic_limit():
|
|
store = BibliographyStore()
|
|
try:
|
|
bootstrapper = Bootstrapper()
|
|
from citegeist import BibEntry
|
|
|
|
bootstrapper.resolver.search_openalex = lambda topic, limit=5: [ # type: ignore[method-assign]
|
|
BibEntry(
|
|
entry_type="article",
|
|
citation_key=f"rank{index}",
|
|
fields={
|
|
"title": f"Preview Topic Result {index}",
|
|
"author": f"Author, {index}",
|
|
"year": f"20{index:02d}",
|
|
"abstract": f"Abstract {index}",
|
|
},
|
|
)
|
|
for index in range(1, 8)
|
|
][:limit]
|
|
bootstrapper.resolver.search_pubmed = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_crossref = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
bootstrapper.resolver.search_datacite = lambda topic, limit=5: [] # type: ignore[method-assign]
|
|
|
|
results = bootstrapper.bootstrap(
|
|
store,
|
|
topic="graph topic",
|
|
expand=False,
|
|
preview_only=True,
|
|
topic_limit=5,
|
|
topic_commit_limit=7,
|
|
)
|
|
|
|
assert [item.citation_key for item in results] == [
|
|
"rank1",
|
|
"rank2",
|
|
"rank3",
|
|
"rank4",
|
|
"rank5",
|
|
"rank6",
|
|
"rank7",
|
|
]
|
|
assert results[0].author == "Author, 1"
|
|
assert results[0].year == "2001"
|
|
assert results[0].abstract == "Abstract 1"
|
|
finally:
|
|
store.close()
|