bibcite-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bibcite-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Resolve papers (arXiv id / DOI / title) to canonical, normalized BibTeX for agents and humans
 Project-URL: Repository, https://github.com/leo1oel/bibcite
 License-Expression: MIT

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bibcite-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "Resolve papers (arXiv id / DOI / title) to canonical, normalized BibTeX for agents and humans"
 readme = "Readme.md"
 license = "MIT"

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/__init__.py

@@ -1,3 +1,3 @@
 """bibcite: canonical BibTeX resolution for papers (arXiv id / DOI / title)."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/bibfile.py

@@ -133,15 +133,37 @@ def load_bib_file(path: Path) -> BibDatabase | None:
         return None
 
 
-def find_existing(db: BibDatabase, title: str, arxiv_id: str = "", doi: str = "") -> dict | None:
+def find_existing(
+    db: BibDatabase,
+    title: str,
+    arxiv_id: str = "",
+    doi: str = "",
+    author: str = "",
+) -> dict | None:
+    from .normalize import first_author_last_name, titles_similar
+
     ref = norm_title(title)
     for entry in db.entries:
         if arxiv_id and entry_arxiv_id(entry) == arxiv_id:
             return entry
-        if doi and entry.get("doi", "").lower() == doi.lower():
-            return entry
+        if doi:
+            d = doi.lower()
+            # Older entries may lack a doi field but carry it in the url.
+            if entry.get("doi", "").lower() == d or d in entry.get("url", "").lower():
+                return entry
         if ref and norm_title(entry.get("title", "")) == ref:
             return entry
+    # Fuzzy pass: title drift (arXiv vs camera-ready) with the same first
+    # author is the same paper — catch it BEFORE writing a duplicate pair.
+    if title and author:
+        last = first_author_last_name(author)
+        for entry in db.entries:
+            if not entry.get("author"):
+                continue
+            if first_author_last_name(entry["author"]) != last:
+                continue
+            if titles_similar(title, entry.get("title", "")):
+                return entry
     return None
 
 
@@ -170,7 +192,11 @@ def upsert_entry(
         existing = next((e for e in db.entries if e.get("ID") == replace_key), None)
     else:
         existing = find_existing(
-            db, entry.get("title", ""), entry_arxiv_id(entry), entry.get("doi", "")
+            db,
+            entry.get("title", ""),
+            entry_arxiv_id(entry),
+            entry.get("doi", ""),
+            entry.get("author", ""),
         )
 
     if existing is not None:
@@ -232,7 +258,28 @@ def tidy_command() -> list[str] | None:
     return None
 
 
+_MONTH_STRING_BLOCK = re.compile(
+    r"@string\s*\{\s*(?:" + "|".join(MONTH_STRINGS) + r")\s*=",
+    re.IGNORECASE,
+)
+
+
+def _scrub_month_strings(path: Path):
+    """Remove orphan month @string blocks left by the pre-0.4 leak.
+    bibtex-tidy itself preserves @strings, so tidy alone never cleans them."""
+    try:
+        if not _MONTH_STRING_BLOCK.search(path.read_text()):
+            return
+        db = load_bib_file(path)
+        if db is not None:
+            _write_db(path, db)  # _write_db drops the injected month macros
+            _log("[bibcite] scrubbed leftover month @string blocks")
+    except Exception as e:
+        _log(f"[bibcite] month-string scrub skipped: {e}")
+
+
 def run_tidy(path: Path) -> bool:
+    _scrub_month_strings(path)
     cmd = tidy_command()
     if cmd is None:
         _log("[bibcite] bibtex-tidy not found (npm i -g bibtex-tidy); skipping tidy")

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/cli.py

@@ -12,7 +12,7 @@ import time
 from pathlib import Path
 
 from . import bibfile, cache
-from .normalize import first_author_last_name, norm_title, titles_similar
+from .normalize import first_author_last_name, fix_pages, norm_title, titles_similar
 from .resolve import classify
 from .resolve import (
     NotFound,
@@ -80,18 +80,18 @@ def cmd_get(args) -> int:
     res, code = _resolve_or_none(query, args.require_published)
     if res is None:
         return code
-    _emit(
-        {
-            "action": "resolved",
-            "key": res.entry["ID"],
-            "title": res.entry.get("title", ""),
-            "venue": res.venue or "arXiv (preprint, no published venue found)",
-            "published": res.published,
-            "source": res.source,
-            "bibtex": res.bibtex,
-        },
-        args.json,
-    )
+    payload = {
+        "action": "resolved",
+        "key": res.entry["ID"],
+        "title": res.entry.get("title", ""),
+        "venue": res.venue or "arXiv (preprint, no published venue found)",
+        "published": res.published,
+        "source": res.source,
+        "bibtex": res.bibtex,
+    }
+    if not res.published:
+        payload["published_check"] = res.check
+    _emit(payload, args.json)
     return 0
 
 
@@ -108,6 +108,8 @@ def _resolve_user_bibtex(text: str) -> Resolved:
         entry.pop("journal", None)
         entry["ENTRYTYPE"] = canonical.entry_type
         entry[canonical.bib_field] = canonical.name
+    if entry.get("pages"):
+        entry["pages"] = fix_pages(entry["pages"])
     published = not bibfile.is_preprint(entry)
     return Resolved(
         entry,
@@ -117,6 +119,31 @@ def _resolve_user_bibtex(text: str) -> Resolved:
     )
 
 
+def _identity_mismatch(path: Path, target_key: str, new_entry: dict) -> str:
+    """`--key` is a scalpel — warn when the resolved paper does not look like
+    the entry it is about to overwrite (no shared arXiv id, DOI, or similar
+    title), because the old key would then be citing a different paper."""
+    db = bibfile.load_bib_file(path)
+    if db is None:
+        return ""
+    target = next((e for e in db.entries if e.get("ID") == target_key), None)
+    if target is None:
+        return ""
+    old_aid, new_aid = bibfile.entry_arxiv_id(target), bibfile.entry_arxiv_id(new_entry)
+    if old_aid and new_aid and old_aid == new_aid:
+        return ""
+    old_doi, new_doi = target.get("doi", "").lower(), new_entry.get("doi", "").lower()
+    if old_doi and new_doi and old_doi == new_doi:
+        return ""
+    if titles_similar(target.get("title", ""), new_entry.get("title", "")):
+        return ""
+    return (
+        f"replacing '{target_key}' with what looks like a DIFFERENT paper "
+        f"('{target.get('title', '')[:50]}' -> '{new_entry.get('title', '')[:50]}'); "
+        "the key will no longer describe its contents"
+    )
+
+
 def _local_exists(path: Path, query: str) -> str | None:
     """Local pre-check: if the query is already in the file as a PUBLISHED
     entry, skip the network entirely (makes --from re-runs and repeated adds
@@ -131,7 +158,12 @@ def _local_exists(path: Path, query: str) -> str | None:
         existing = bibfile.find_existing(db, "", doi=value)
     else:
         existing = bibfile.find_existing(db, value)
-    if existing is not None and not bibfile.is_preprint(existing):
+    if existing is None:
+        return None
+    if not bibfile.is_preprint(existing):
+        return existing["ID"]
+    if existing.get("pubstate", "").strip("{}") == "preprint":
+        # Confirmed preprint-only: nothing to upgrade, no reason to go online.
         return existing["ID"]
     return None
 
@@ -196,6 +228,11 @@ def cmd_add(args) -> int:
         if res is None:
             results.append({"query": query, "action": "failed", "exit_code": code})
             continue
+        warning = ""
+        if args.key:
+            warning = _identity_mismatch(path, args.key, res.entry)
+            if warning:
+                _log(f"[bibcite] warning: {warning}")
         action, key = bibfile.upsert_entry(
             path, res.entry, replace=args.replace, replace_key=args.key or ""
         )
@@ -210,17 +247,22 @@ def cmd_add(args) -> int:
             results.append({"query": query, "action": action, "exit_code": EXIT_NOT_FOUND})
             continue
         wrote = wrote or action != "exists"
-        results.append(
-            {
-                "query": query,
-                "action": action,
-                "key": key,
-                "title": res.entry.get("title", ""),
-                "venue": res.venue or "arXiv (preprint)",
-                "published": res.published,
-                "source": res.source,
-            }
-        )
+        result = {
+            "query": query,
+            "action": action,
+            "key": key,
+            "title": res.entry.get("title", ""),
+            "venue": res.venue or "arXiv (preprint)",
+            "published": res.published,
+            "source": res.source,
+        }
+        if not res.published:
+            # "incomplete" = the check ran while core sources were down; the
+            # paper may well be published — retry later.
+            result["published_check"] = res.check
+        if warning:
+            result["warning"] = warning
+        results.append(result)
 
     tidied = False
     if wrote and not args.no_tidy:
@@ -274,10 +316,13 @@ def _upgrade_entries(path: Path, dry_run: bool) -> dict:
         )
         match, status = find_published(title, entry.get("year", ""), aid, hint)
         if not match:
-            # "no_published_version" is a trustworthy miss; "sources_unavailable"
-            # means the sources were down — do not conclude anything.
+            # "no_published_version" is trustworthy ONLY when every core
+            # source answered; a batch that tripped DBLP's rate limit gets
+            # "sources_unavailable" so nobody believes a poisoned verdict.
             reason = (
-                "sources_unavailable" if status == "unavailable" else "no_published_version"
+                "no_published_version"
+                if status == "not_found"
+                else "sources_unavailable"
             )
             report.append(
                 {"key": entry["ID"], "title": title, "matched": False, "reason": reason}

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/normalize.py

@@ -82,14 +82,22 @@ def sig_tokens(title: str) -> set[str]:
     return {t for t in tokens if len(t) > 2 and t not in ENGLISH_STOPWORDS}
 
 
-def titles_similar(a: str, b: str, threshold: float = 0.7) -> bool:
-    """Token-Jaccard similarity — catches preprint→camera-ready title drift
+def titles_similar(a: str, b: str, threshold: float = 0.75) -> bool:
+    """Token-overlap similarity — catches preprint→camera-ready title drift
     ("Information-Theoretic Perspective" vs "Information Theory Perspective")
-    without matching genuinely different papers."""
+    without matching genuinely different papers.
+
+    Uses the overlap coefficient (|∩| / min) rather than Jaccard so one
+    changed word in a shortish title still matches; very short titles
+    (<=3 significant tokens, e.g. "Deep Learning") must match exactly
+    because a single shared word would otherwise dominate."""
     ta, tb = sig_tokens(a), sig_tokens(b)
     if not ta or not tb:
         return False
-    return len(ta & tb) / len(ta | tb) >= threshold
+    smaller = min(len(ta), len(tb))
+    if smaller <= 3:
+        return ta == tb
+    return len(ta & tb) / smaller >= threshold
 
 
 def fix_author_caps(author_field: str) -> str:
@@ -114,6 +122,12 @@ def fix_author_caps(author_field: str) -> str:
     return " and ".join(fix_name(n) for n in names)
 
 
+def fix_pages(pages: str) -> str:
+    """BibTeX page ranges use `--`; CrossRef emits en-dashes (411–430) and
+    some sources a single hyphen. Collapse any dash run to `--`."""
+    return re.sub(r"\s*[-‐-―]+\s*", "--", pages.strip())
+
+
 def make_key(author_field: str, year: str | int, title: str) -> str:
     """Deterministic citation key: <lastname><year><firstword>.
 

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/resolve.py

@@ -10,7 +10,13 @@ import sys
 from dataclasses import dataclass
 
 from .bibfile import NOISE_FIELDS, parse_bibtex_entry
-from .normalize import clean_title, first_author_last_name, fix_author_caps, make_key
+from .normalize import (
+    clean_title,
+    first_author_last_name,
+    fix_author_caps,
+    fix_pages,
+    make_key,
+)
 
 
 class NotFound(Exception):
@@ -66,6 +72,12 @@ class Resolved:
     source: str  # where the publication info came from
     venue: str  # final venue string ("" if preprint)
     published: bool
+    # For preprint fallbacks: was the publication check trustworthy?
+    # "complete"   — every core source answered; the paper really has no
+    #                published version (as of now)
+    # "incomplete" — core sources were rate-limited/down; retry later before
+    #                believing the preprint status
+    check: str = "complete"
 
     @property
     def bibtex(self) -> str:
@@ -153,6 +165,8 @@ def _finalize(entry: dict, meta: ArxivMeta | None) -> dict:
         # a missing url from the DOI.
         if not url or "dx.doi.org" in url:
             entry["url"] = f"https://doi.org/{entry['doi']}"
+    if entry.get("pages"):
+        entry["pages"] = fix_pages(entry["pages"])
     author = entry.get("author", "") or "anonymous"
     year = entry.get("year", "") or "XXXX"
     entry["ID"] = make_key(author, year, entry.get("title", ""))
@@ -212,9 +226,16 @@ def resolve(query: str, require_published: bool = False) -> Resolved:
                     f"Could not check publication status for arXiv:{value} (sources down)"
                 )
             raise NotFound(f"No published version found for arXiv:{value}")
-        _log("[bibcite] no published version found; using arXiv preprint entry")
+        check = "complete" if status == "not_found" else "incomplete"
+        if check == "incomplete":
+            _log(
+                "[bibcite] preprint fallback with INCOMPLETE publication check "
+                "(core sources were unavailable) — retry later"
+            )
+        else:
+            _log("[bibcite] no published version found; using arXiv preprint entry")
         entry = _arxiv_only_entry(meta)
-        return Resolved(_finalize(entry, meta), "arxiv", "", False)
+        return Resolved(_finalize(entry, meta), "arxiv", "", False, check)
 
     if kind == "doi":
         match = crossref_by_doi(value)
@@ -248,9 +269,16 @@ def resolve(query: str, require_published: bool = False) -> Resolved:
     if meta and meta.arxiv_id:
         if require_published:
             raise NotFound(f"Only an arXiv preprint was found for: {value}")
-        _log("[bibcite] no published version found; using arXiv preprint entry")
+        check = "complete" if status == "not_found" else "incomplete"
+        if check == "incomplete":
+            _log(
+                "[bibcite] preprint fallback with INCOMPLETE publication check "
+                "(core sources were unavailable) — retry later"
+            )
+        else:
+            _log("[bibcite] no published version found; using arXiv preprint entry")
         entry = _arxiv_only_entry(meta)
-        return Resolved(_finalize(entry, meta), "arxiv", "", False)
+        return Resolved(_finalize(entry, meta), "arxiv", "", False, check)
     if status == "unavailable":
         raise SourcesUnavailable(
             f"All sources were rate-limited or down while resolving: {value}"

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/src/bibcite/sources.py

@@ -147,6 +147,42 @@ def arxiv_metadata(arxiv_id: str) -> ArxivMeta:
 # DBLP
 # ---------------------------------------------------------------------------
 
+# DBLP throttles at roughly 1-2 req/s and escalates to temporary IP bans when
+# hammered. Client-side pacing prevents the 429 in the first place; on a 429
+# we back off and retry (honoring Retry-After) instead of instantly poisoning
+# the rest of a batch run — only repeated failure disables the source.
+_DBLP_MIN_INTERVAL = 0.8
+_dblp_last_request = 0.0
+
+
+def _dblp_get(c: httpx.Client, url: str, params: dict | None = None) -> httpx.Response:
+    global _dblp_last_request
+    for attempt in range(3):
+        wait = _DBLP_MIN_INTERVAL - (time.monotonic() - _dblp_last_request)
+        if wait > 0:
+            time.sleep(wait)
+        _dblp_last_request = time.monotonic()
+        try:
+            r = c.get(url, params=params)
+        except httpx.HTTPError as e:  # TCP reset = temporary ban; retrying fast makes it worse
+            if attempt < 2:
+                time.sleep(5 * (attempt + 1))
+                continue
+            raise SourceUnavailable(f"DBLP unreachable ({type(e).__name__})")
+        if r.status_code == 429:
+            retry_after = int(r.headers.get("Retry-After") or 0)
+            if retry_after > 30:
+                raise SourceUnavailable(f"DBLP rate-limited (Retry-After {retry_after}s)")
+            if attempt < 2:
+                delay = max(retry_after, 4 * (attempt + 1))
+                _log(f"[dblp] 429 — backing off {delay}s")
+                time.sleep(delay)
+                continue
+            raise SourceUnavailable("DBLP rate-limited (429) after backoff retries")
+        return r
+    raise SourceUnavailable("DBLP unavailable")
+
+
 def try_dblp(title: str, author_hint: str = "") -> Match | None:
     """DBLP search. Generic titles ("X is all you need") drown in DBLP's
     ranking, so when we know the first author we query with their last name
@@ -157,12 +193,11 @@ def try_dblp(title: str, author_hint: str = "") -> Match | None:
     queries.append(title)
     with _client() as c:
         for q in queries:
-            r = c.get(
+            r = _dblp_get(
+                c,
                 "https://dblp.org/search/publ/api",
                 params={"q": q, "format": "json", "h": 100},
             )
-            if r.status_code == 429:
-                raise SourceUnavailable("DBLP rate-limited (429)")
             r.raise_for_status()
             hits = (
                 r.json().get("result", {}).get("hits", {}).get("hit", []) or []
@@ -182,9 +217,12 @@ def try_dblp(title: str, author_hint: str = "") -> Match | None:
                     venue = venue[0]
                 bibtex = ""
                 if info.get("url"):
-                    br = c.get(info["url"] + ".bib")
-                    if br.status_code == 200:
-                        bibtex = br.text
+                    try:
+                        br = _dblp_get(c, info["url"] + ".bib")
+                        if br.status_code == 200:
+                            bibtex = br.text
+                    except SourceUnavailable:
+                        pass  # keep the match; construct from fields
                 _log(f"[dblp] match: {venue} {info.get('year', '')}")
                 return Match(
                     source="dblp",
@@ -219,12 +257,11 @@ def try_dblp_fuzzy(title: str, author_hint: str, year: str = "") -> Match | None
         return None
     q = " ".join([author_hint] + tokens)
     with _client() as c:
-        r = c.get(
+        r = _dblp_get(
+            c,
             "https://dblp.org/search/publ/api",
             params={"q": q, "format": "json", "h": 100},
         )
-        if r.status_code == 429:
-            raise SourceUnavailable("DBLP rate-limited (429)")
         r.raise_for_status()
         hits = r.json().get("result", {}).get("hits", {}).get("hit", []) or []
         hits.sort(key=lambda h: int(h.get("info", {}).get("year", 9999)))
@@ -246,9 +283,12 @@ def try_dblp_fuzzy(title: str, author_hint: str, year: str = "") -> Match | None
                 venue = venue[0]
             bibtex = ""
             if info.get("url"):
-                br = c.get(info["url"] + ".bib")
-                if br.status_code == 200:
-                    bibtex = br.text
+                try:
+                    br = _dblp_get(c, info["url"] + ".bib")
+                    if br.status_code == 200:
+                        bibtex = br.text
+                except SourceUnavailable:
+                    pass  # keep the match; construct from fields
             _log(
                 f"[dblp-fuzzy] match with title drift: '{hit_title}' "
                 f"@ {venue} {info.get('year', '')}"
@@ -659,16 +699,24 @@ CASCADE = (
 # (PaperMemory's DISABLE_MATCH, ported).
 _DISABLED: dict[str, str] = {}
 
+# Only these sources are authoritative enough that losing one taints a miss
+# into "incomplete". Google Scholar captchas and Unpaywall flakiness are
+# routine and must not stop "not_found" from ever being trustworthy.
+CORE_SOURCES = frozenset({"dblp", "semanticscholar", "crossref", "openalex"})
+
 
 def find_published(
     title: str, year: str = "", arxiv_id: str = "", author_hint: str = ""
 ) -> tuple[Match | None, str]:
     """Try each source in order; first verified hit wins.
 
-    Returns (match, status). status distinguishes a trustworthy miss from an
-    outage: "found" | "not_found" (>=1 source answered cleanly with no hit) |
-    "unavailable" (every source was disabled or errored — do NOT conclude the
-    paper is unpublished).
+    Returns (match, status):
+      "found"       — verified publication match
+      "not_found"   — EVERY source answered cleanly with no hit; trustworthy
+      "incomplete"  — some sources answered (no hit) but others were
+                      disabled/erroring; a batch run that tripped DBLP's rate
+                      limit lands here — do NOT conclude "unpublished"
+      "unavailable" — no source answered at all
     """
     from . import cache
 
@@ -679,6 +727,8 @@ def find_published(
         return Match(**cached), "found"
 
     clean_misses = 0
+    # Core sources lost earlier in this run taint this query's verdict too.
+    incomplete = any(n in CORE_SOURCES for n in _DISABLED)
     for name, fn in CASCADE:
         if name in _DISABLED:
             continue
@@ -691,8 +741,10 @@ def find_published(
             _log(f"[{name}] no publication found")
         except SourceUnavailable as e:
             _DISABLED[name] = str(e)
+            incomplete = incomplete or name in CORE_SOURCES
             _log(f"[{name}] disabled for the rest of this run: {e}")
         except Exception as e:  # network hiccup on one source must not kill the run
+            incomplete = incomplete or name in CORE_SOURCES
             _log(f"[{name}] error: {type(e).__name__}: {e}")
 
     # Exact-title search missed everywhere. Before concluding "no published
@@ -707,6 +759,10 @@ def find_published(
             clean_misses += 1
         except SourceUnavailable as e:
             _DISABLED["dblp"] = str(e)
+            incomplete = True
         except Exception as e:
+            incomplete = True
             _log(f"[dblp-fuzzy] error: {type(e).__name__}: {e}")
-    return None, ("not_found" if clean_misses else "unavailable")
+    if not clean_misses:
+        return None, "unavailable"
+    return None, ("incomplete" if incomplete else "not_found")

bibcite_cli-0.5.0/tests/test_round3.py

@@ -0,0 +1,86 @@
+"""Regression tests for the third round of field-use reports."""
+
+from pathlib import Path
+
+from bibcite.bibfile import (
+    _scrub_month_strings,
+    find_existing,
+    load_bib_file,
+    upsert_entry,
+)
+from bibcite.normalize import fix_pages
+
+
+def test_fix_pages_dashes():
+    assert fix_pages("411–430") == "411--430"  # en-dash
+    assert fix_pages("411-430") == "411--430"  # single hyphen
+    assert fix_pages("411 -- 430") == "411--430"
+    assert fix_pages("723—726") == "723--726"  # em-dash
+    assert fix_pages("e123") == "e123"  # no range untouched
+
+
+PREPRINT = {
+    "ENTRYTYPE": "misc",
+    "ID": "old",
+    "title": "An Information-Theoretic Perspective on VICReg",
+    "author": "Ravid Shwartz-Ziv and Yann LeCun",
+    "howpublished": "arXiv preprint arXiv:2303.00633",
+    "eprint": "2303.00633",
+    "year": "2023",
+}
+
+
+def test_find_existing_by_doi_in_url(tmp_path: Path):
+    bib = tmp_path / "d.bib"
+    upsert_entry(
+        bib,
+        {
+            "ENTRYTYPE": "article",
+            "ID": "k",
+            "title": "T",
+            "author": "A B",
+            "journal": "J",
+            "year": "2000",
+            "url": "https://doi.org/10.1093/biomet/70.3.723",
+        },
+    )
+    db = load_bib_file(bib)
+    # No doi field on the entry — matched via the url (pre-0.4.0 files).
+    assert find_existing(db, "", doi="10.1093/biomet/70.3.723") is not None
+
+
+def test_dedupe_catches_title_drift_pair(tmp_path: Path):
+    bib = tmp_path / "p.bib"
+    upsert_entry(bib, dict(PREPRINT))
+    published = {
+        "ENTRYTYPE": "inproceedings",
+        "ID": "new",
+        "title": "An Information Theory Perspective on VICReg",  # drifted
+        "author": "Ravid Shwartz-Ziv and Yann LeCun",
+        "booktitle": "Advances in Neural Information Processing Systems (NeurIPS)",
+        "year": "2023",
+    }
+    action, key = upsert_entry(bib, published)
+    # Fuzzy same-author dedupe: upgraded in place, NOT added as a duplicate.
+    assert (action, key) == ("upgraded", "old")
+    assert bib.read_text().count("@") == 1
+
+
+def test_scrub_orphan_month_strings(tmp_path: Path):
+    bib = tmp_path / "m.bib"
+    bib.write_text(
+        "@string{january = {January}}\n@string{june = {June}}\n"
+        "@article{x, title = {T}, author = {A B}, year = {2000} }\n"
+    )
+    _scrub_month_strings(bib)
+    text = bib.read_text()
+    assert "@string" not in text
+    assert "title" in text
+
+
+def test_scrub_leaves_clean_files_alone(tmp_path: Path):
+    bib = tmp_path / "c.bib"
+    original = "@article{x,\n  title = {T},\n  author = {A B},\n  year = {2000},\n}\n"
+    bib.write_text(original)
+    _scrub_month_strings(bib)
+    assert bib.read_text() == original  # untouched, not even rewritten

bibcite_cli-0.5.0/tests/test_status_semantics.py

@@ -0,0 +1,78 @@
+"""The batch-429 poisoning scenario: a disabled core source must taint the
+verdict ('incomplete'), never masquerade as a trustworthy 'not_found'."""
+
+import pytest
+
+import bibcite.sources as sources
+from bibcite import cache
+from bibcite.sources import SourceUnavailable, find_published
+
+
+@pytest.fixture(autouse=True)
+def isolated(monkeypatch, tmp_path):
+    monkeypatch.setattr(cache, "DISABLED", True)
+    monkeypatch.setattr(sources, "_DISABLED", {})
+    # No fuzzy fallback network calls in these tests.
+    monkeypatch.setattr(sources, "try_dblp_fuzzy", lambda *a, **k: None)
+
+
+def _cascade(**outcomes):
+    """Build a fake CASCADE; outcome per source: None=clean miss, 'raise'=429."""
+
+    def make(o):
+        def fn(t, y, a, au):
+            if o == "raise":
+                raise SourceUnavailable("simulated 429")
+            return o
+
+        return fn
+
+    return tuple((name, make(o)) for name, o in outcomes.items())
+
+
+def test_all_clean_misses_is_trustworthy(monkeypatch):
+    monkeypatch.setattr(
+        sources, "CASCADE", _cascade(dblp=None, semanticscholar=None, crossref=None)
+    )
+    match, status = find_published("Some Title", author_hint="smith")
+    assert (match, status) == (None, "not_found")
+
+
+def test_core_source_429_taints_verdict(monkeypatch):
+    # DBLP 429s, others answer cleanly — the user's exact failure chain.
+    monkeypatch.setattr(
+        sources,
+        "CASCADE",
+        _cascade(dblp="raise", googlescholar=None, crossref=None),
+    )
+    match, status = find_published("Some Title", author_hint="smith")
+    assert (match, status) == (None, "incomplete")
+
+
+def test_previously_disabled_core_source_taints_next_queries(monkeypatch):
+    # Query N tripped DBLP; queries N+1... in the same run inherit the taint.
+    monkeypatch.setattr(sources, "_DISABLED", {"dblp": "429"})
+    monkeypatch.setattr(
+        sources, "CASCADE", _cascade(dblp=None, crossref=None)  # dblp skipped anyway
+    )
+    match, status = find_published("Another Title", author_hint="smith")
+    assert (match, status) == (None, "incomplete")
+
+
+def test_noncore_outage_does_not_taint(monkeypatch):
+    # Google Scholar captcha is routine; a miss stays trustworthy.
+    monkeypatch.setattr(
+        sources,
+        "CASCADE",
+        _cascade(dblp=None, googlescholar="raise", crossref=None),
+    )
+    match, status = find_published("Some Title", author_hint="smith")
+    assert (match, status) == (None, "not_found")
+
+
+def test_everything_down_is_unavailable(monkeypatch):
+    monkeypatch.setattr(
+        sources, "CASCADE", _cascade(dblp="raise", semanticscholar="raise")
+    )
+    match, status = find_published("Some Title", author_hint="smith")
+    assert (match, status) == (None, "unavailable")

{bibcite_cli-0.4.0 → bibcite_cli-0.5.0}/uv.lock

@@ -18,7 +18,7 @@ wheels = [
 
 [[package]]
 name = "bibcite-cli"
-version = "0.4.0"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "bibtexparser" },