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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bibcite-cli
-Version: 0.4.0
+Version: 0.4.1
 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.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bibcite-cli"
-version = "0.4.0"
+version = "0.4.1"
 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.4.1}/src/bibcite/__init__.py

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

{bibcite_cli-0.4.0 → bibcite_cli-0.4.1}/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.4.1}/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,
@@ -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,18 @@ 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 warning:
+            result["warning"] = warning
+        results.append(result)
 
     tidied = False
     if wrote and not args.no_tidy:

{bibcite_cli-0.4.0 → bibcite_cli-0.4.1}/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.4.1}/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):
@@ -153,6 +159,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", ""))

bibcite_cli-0.4.1/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.4.0 → bibcite_cli-0.4.1}/uv.lock

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