bibcite-cli 0.6.4__tar.gz → 0.6.5__tar.gz

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bibcite-cli
-Version: 0.6.4
+Version: 0.6.5
 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
@@ -158,10 +158,15 @@ Mark a confirmed preprint-only entry with `pubstate = {preprint}` if you want `c
 
 ## How resolution works
 
-For arXiv IDs and titles, `bibcite` collects paper metadata and checks publication sources in a cascade derived from [PaperMemory](https://github.com/vict0rsch/PaperMemory): DBLP, Semantic Scholar, Crossref, Unpaywall, and OpenAlex.
+For arXiv IDs and titles, `bibcite` collects paper metadata and checks publication sources in a cascade derived from [PaperMemory](https://github.com/vict0rsch/PaperMemory): DBLP, Semantic Scholar, Crossref, and OpenAlex.
 Google Scholar scraping is excluded so CAPTCHA challenges cannot delay publication lookup.
 A published match must have the same normalized title or pass a guarded title-drift check, have a plausible publication year, and name a non-preprint venue.
 
+DBLP requests are single-attempt, with short connection/read timeouts and a shared four-second scheduling budget for exact and title-drift lookup.
+Socket timeouts apply per network phase, so this budget is not a hard end-to-end deadline.
+Published DBLP records are constructed from the search response, without another request for a BibTeX export.
+A failed or unfinished DBLP check stays incomplete rather than being treated as evidence that a paper is unpublished.
+
 Successful published matches are cached at `~/.cache/bibcite/published.json`.
 Preprint-only results are never cached because a paper may be published later.
 Use `--no-cache` or set `BIBCITE_NO_CACHE=1` to bypass the cache.
@@ -176,7 +181,7 @@ These optional environment variables improve source reliability:
 | --- | --- |
 | `OPENALEX_API_KEY` | Uses your OpenAlex quota instead of the anonymous shared pool. |
 | `S2_API_KEY` | Uses a private Semantic Scholar quota. |
-| `BIBCITE_MAILTO` | Sends your contact email to the Crossref, OpenAlex, and Unpaywall polite pools. |
+| `BIBCITE_MAILTO` | Sends your contact email to the Crossref and OpenAlex polite pools. |
 | `BIBCITE_PUBLIC_SERVICE_URL` | Routes keyless OpenAlex, Semantic Scholar, and Crossref requests through an HTTPS `/v1/query` service supplied by the embedding application. |
 | `BIBCITE_CORE_SOURCES` | Overrides the sources required for a trustworthy publication check. |
 | `BIBCITE_NO_CACHE=1` | Disables the local publication cache. |
@@ -213,7 +218,7 @@ uv tool install --editable .
 
 ## Acknowledgements
 
-Inspired by [PaperMemory](https://github.com/vict0rsch/PaperMemory), with formatting by [bibtex-tidy](https://github.com/FlamingTempura/bibtex-tidy) and metadata from arXiv, DBLP, Semantic Scholar, Crossref, Unpaywall, and OpenAlex.
+Inspired by [PaperMemory](https://github.com/vict0rsch/PaperMemory), with formatting by [bibtex-tidy](https://github.com/FlamingTempura/bibtex-tidy) and metadata from arXiv, DBLP, Semantic Scholar, Crossref, and OpenAlex.
 
 ## License
 

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/Readme.md

@@ -145,10 +145,15 @@ Mark a confirmed preprint-only entry with `pubstate = {preprint}` if you want `c
 
 ## How resolution works
 
-For arXiv IDs and titles, `bibcite` collects paper metadata and checks publication sources in a cascade derived from [PaperMemory](https://github.com/vict0rsch/PaperMemory): DBLP, Semantic Scholar, Crossref, Unpaywall, and OpenAlex.
+For arXiv IDs and titles, `bibcite` collects paper metadata and checks publication sources in a cascade derived from [PaperMemory](https://github.com/vict0rsch/PaperMemory): DBLP, Semantic Scholar, Crossref, and OpenAlex.
 Google Scholar scraping is excluded so CAPTCHA challenges cannot delay publication lookup.
 A published match must have the same normalized title or pass a guarded title-drift check, have a plausible publication year, and name a non-preprint venue.
 
+DBLP requests are single-attempt, with short connection/read timeouts and a shared four-second scheduling budget for exact and title-drift lookup.
+Socket timeouts apply per network phase, so this budget is not a hard end-to-end deadline.
+Published DBLP records are constructed from the search response, without another request for a BibTeX export.
+A failed or unfinished DBLP check stays incomplete rather than being treated as evidence that a paper is unpublished.
+
 Successful published matches are cached at `~/.cache/bibcite/published.json`.
 Preprint-only results are never cached because a paper may be published later.
 Use `--no-cache` or set `BIBCITE_NO_CACHE=1` to bypass the cache.
@@ -163,7 +168,7 @@ These optional environment variables improve source reliability:
 | --- | --- |
 | `OPENALEX_API_KEY` | Uses your OpenAlex quota instead of the anonymous shared pool. |
 | `S2_API_KEY` | Uses a private Semantic Scholar quota. |
-| `BIBCITE_MAILTO` | Sends your contact email to the Crossref, OpenAlex, and Unpaywall polite pools. |
+| `BIBCITE_MAILTO` | Sends your contact email to the Crossref and OpenAlex polite pools. |
 | `BIBCITE_PUBLIC_SERVICE_URL` | Routes keyless OpenAlex, Semantic Scholar, and Crossref requests through an HTTPS `/v1/query` service supplied by the embedding application. |
 | `BIBCITE_CORE_SOURCES` | Overrides the sources required for a trustworthy publication check. |
 | `BIBCITE_NO_CACHE=1` | Disables the local publication cache. |
@@ -200,7 +205,7 @@ uv tool install --editable .
 
 ## Acknowledgements
 
-Inspired by [PaperMemory](https://github.com/vict0rsch/PaperMemory), with formatting by [bibtex-tidy](https://github.com/FlamingTempura/bibtex-tidy) and metadata from arXiv, DBLP, Semantic Scholar, Crossref, Unpaywall, and OpenAlex.
+Inspired by [PaperMemory](https://github.com/vict0rsch/PaperMemory), with formatting by [bibtex-tidy](https://github.com/FlamingTempura/bibtex-tidy) and metadata from arXiv, DBLP, Semantic Scholar, Crossref, and OpenAlex.
 
 ## License
 

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/pyproject.toml

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

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/src/bibcite/sources.py

@@ -1,7 +1,7 @@
 """API clients for the publication-matching cascade.
 
 Order and matching rules ported from PaperMemory's bibMatcher:
-DBLP -> Semantic Scholar -> CrossRef -> Unpaywall -> OpenAlex.
+DBLP -> Semantic Scholar -> CrossRef -> OpenAlex.
 All matchers verify identity via normalized-title equality and reject
 preprint venues (arXiv / CoRR / bioRxiv / ...).
 """
@@ -78,7 +78,11 @@ def _request_timeout(cap: float = TIMEOUT) -> float:
 
 
 def _get(
-    c: httpx.Client, url: str, *, timeout: float = TIMEOUT, **kwargs
+    c: httpx.Client,
+    url: str,
+    *,
+    timeout: float | httpx.Timeout = TIMEOUT,
+    **kwargs,
 ) -> httpx.Response:
     """GET directly or route keyless supported APIs through the public service."""
     public_url = os.environ.get("BIBCITE_PUBLIC_SERVICE_URL")
@@ -98,7 +102,10 @@ def _get(
         "crossref": bool(os.environ.get("BIBCITE_MAILTO")),
     }
     if not public_url or not provider or personal_access[provider]:
-        return c.get(url, timeout=_request_timeout(timeout), **kwargs)
+        effective_timeout = (
+            timeout if isinstance(timeout, httpx.Timeout) else _request_timeout(timeout)
+        )
+        return c.get(url, timeout=effective_timeout, **kwargs)
 
     service = urlsplit(public_url)
     loopback = service.hostname in {"localhost", "127.0.0.1", "::1"}
@@ -183,7 +190,7 @@ def _s2_headers() -> dict:
 
 
 def _mailto() -> str:
-    """Contact email for the polite pools (CrossRef/OpenAlex/Unpaywall).
+    """Contact email for the polite pools (CrossRef/OpenAlex).
     Set BIBCITE_MAILTO to use your own."""
     return os.environ.get("BIBCITE_MAILTO") or "bibcite@gmail.com"
 
@@ -340,7 +347,26 @@ def _paced_get(
 
 # DBLP throttles at roughly 1-2 req/s and escalates to temporary IP bans.
 def _dblp_get(c: httpx.Client, url: str, params: dict | None = None) -> httpx.Response:
-    return _paced_get(c, url, "dblp", 0.8, params=params)
+    wait = 0.8 - (time.monotonic() - _LAST_REQUEST.get("dblp", 0.0))
+    if wait > 0:
+        _sleep(wait)
+    _LAST_REQUEST["dblp"] = time.monotonic()
+    remaining = _request_timeout(2.5)
+    timeout = httpx.Timeout(
+        connect=min(1.5, remaining),
+        read=min(2.5, remaining),
+        write=min(1.0, remaining),
+        pool=min(1.0, remaining),
+    )
+    try:
+        response = _get(c, url, params=params, timeout=timeout)
+    except httpx.HTTPError as e:
+        raise TransientSourceError(f"dblp unreachable ({type(e).__name__})") from e
+    if response.status_code == 429:
+        raise SourceUnavailable("dblp rate-limited (429)")
+    if response.status_code >= 500:
+        raise TransientSourceError(f"dblp server error ({response.status_code})")
+    return response
 
 
 def _dblp_sanitize(q: str) -> str:
@@ -352,19 +378,76 @@ def _dblp_sanitize(q: str) -> str:
 
 
 def _dblp_search(c: httpx.Client, q: str, h: int = 100) -> list:
-    """One search request; a 500 (broad all-common-words query × large h
-    times out their backend) is retried once with a small result window
-    before giving up on this query variant."""
+    """Run one DBLP search while retaining the full result window."""
     url = "https://dblp.org/search/publ/api"
     q = _dblp_sanitize(q)
     r = _dblp_get(c, url, params={"q": q, "format": "json", "h": h})
-    if r.status_code == 500 and h > 10:
-        _log("[dblp] 500 on broad query — retrying with h=10")
-        r = _dblp_get(c, url, params={"q": q, "format": "json", "h": 10})
     r.raise_for_status()
     return r.json().get("result", {}).get("hits", {}).get("hit", []) or []
 
 
+def _dblp_bibtex(info: dict, venue: str) -> str:
+    """Build the DBLP record from search JSON, avoiding a second .bib request."""
+    from .bibfile import entry_to_bibtex
+
+    record_type = str(info.get("type", "")).lower()
+    key = str(info.get("key") or "dblp")
+    if record_type == "editorship":
+        entry_type = "proceedings" if key.startswith("conf/") else "book"
+    elif key.startswith("phd/"):
+        entry_type = "phdthesis"
+    elif record_type == "parts in books or collections":
+        entry_type = "incollection"
+    elif record_type == "books and theses":
+        entry_type = "book"
+    else:
+        entry_type = (
+            "inproceedings"
+            if "conference" in record_type or key.startswith("conf/")
+            else "article"
+        )
+    fields = {
+        "ID": key,
+        "ENTRYTYPE": entry_type,
+        "author": " and ".join(_dblp_hit_authors(info)),
+        "title": clean_title(html.unescape(str(info.get("title", "")))),
+        "year": str(info.get("year", "")),
+        "pages": str(info.get("pages", "")),
+        "volume": str(info.get("volume", "")),
+        "number": str(info.get("number", "")),
+        "doi": str(info.get("doi", "")),
+        "url": str(info.get("ee") or info.get("url") or ""),
+        "publisher": str(info.get("publisher", "")),
+        "editor": str(info.get("editor", "")),
+        "isbn": str(info.get("isbn", "")),
+    }
+    if entry_type in {"inproceedings", "incollection"}:
+        fields["booktitle"] = venue
+    elif entry_type == "article":
+        fields["journal"] = venue
+    if record_type == "editorship":
+        fields["editor"] = fields["editor"] or fields["author"]
+        fields.pop("author")
+    return entry_to_bibtex(fields)
+
+
+def _dblp_match(info: dict, source: str) -> Match:
+    venue = info["venue"]
+    if isinstance(venue, list):
+        venue = venue[0]
+    title = clean_title(html.unescape(info.get("title", "")))
+    return Match(
+        source=source,
+        venue=str(venue),
+        title=title,
+        year=str(info.get("year", "")),
+        authors=_dblp_hit_authors(info),
+        doi=info.get("doi", ""),
+        bibtex=_dblp_bibtex(info, str(venue)),
+        url=info.get("ee", "") or info.get("url", ""),
+    )
+
+
 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
@@ -386,27 +469,10 @@ def try_dblp(title: str, author_hint: str = "") -> Match | None:
                     continue
                 if info.get("venue") == "CoRR" or not info.get("venue"):
                     continue
-                venue = info["venue"]
-                if isinstance(venue, list):
-                    venue = venue[0]
-                bibtex = ""
-                if info.get("url"):
-                    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
+                match = _dblp_match(info, "dblp")
+                venue = match.venue
                 _log(f"[dblp] match: {venue} {info.get('year', '')}")
-                return Match(
-                    source="dblp",
-                    venue=str(venue),
-                    title=clean_title(html.unescape(info.get("title", ""))),
-                    year=str(info.get("year", "")),
-                    doi=info.get("doi", ""),
-                    bibtex=bibtex,
-                    url=info.get("ee", "") or info.get("url", ""),
-                )
+                return match
     return None
 
 
@@ -414,7 +480,11 @@ def _dblp_hit_authors(info: dict) -> list[str]:
     authors = (info.get("authors") or {}).get("author") or []
     if isinstance(authors, dict):
         authors = [authors]
-    return [a.get("text", "") for a in authors if isinstance(a, dict)]
+    return [
+        re.sub(r"\s+\d{4}$", "", a.get("text", ""))
+        for a in authors
+        if isinstance(a, dict) and a.get("text")
+    ]
 
 
 def try_dblp_fuzzy(title: str, author_hint: str, year: str = "") -> Match | None:
@@ -446,30 +516,13 @@ def try_dblp_fuzzy(title: str, author_hint: str, year: str = "") -> Match | None
             hit_authors = mini_hash(" ".join(_dblp_hit_authors(info)))
             if author_hint not in hit_authors:
                 continue
-            venue = info["venue"]
-            if isinstance(venue, list):
-                venue = venue[0]
-            bibtex = ""
-            if info.get("url"):
-                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
+            match = _dblp_match(info, "dblp-fuzzy")
+            venue = match.venue
             _log(
                 f"[dblp-fuzzy] match with title drift: '{hit_title}' "
                 f"@ {venue} {info.get('year', '')}"
             )
-            return Match(
-                source="dblp-fuzzy",
-                venue=str(venue),
-                title=hit_title,
-                year=str(info.get("year", "")),
-                doi=info.get("doi", ""),
-                bibtex=bibtex,
-                url=info.get("ee", "") or info.get("url", ""),
-            )
+            return match
     return None
 
 
@@ -615,9 +668,8 @@ def try_crossref(title: str) -> Match | None:
         if r.status_code == 429:
             raise SourceUnavailable("CrossRef rate-limited (429)")
         if r.status_code >= 500:
-            # A dead endpoint (Unpaywall search 500s for days at a time)
-            # gets benched for the run instead of adding latency + noise
-            # to every remaining query.
+            # A dead endpoint gets benched for the run instead of adding
+            # latency and noise to every remaining query.
             raise SourceUnavailable(f"CrossRef server error ({r.status_code})")
         r.raise_for_status()
         payload = r.json()
@@ -660,52 +712,6 @@ def try_crossref(title: str) -> Match | None:
     return None
 
 
-# ---------------------------------------------------------------------------
-# Unpaywall
-# ---------------------------------------------------------------------------
-
-def try_unpaywall(title: str) -> Match | None:
-    with _client() as c:
-        r = _get(
-            c,
-            "https://api.unpaywall.org/v2/search",
-            params={"query": title, "is_oa": "true", "email": _mailto()},
-        )
-        if r.status_code == 429:
-            raise SourceUnavailable("Unpaywall rate-limited (429)")
-        if r.status_code >= 500:
-            # A dead endpoint (Unpaywall search 500s for days at a time)
-            # gets benched for the run instead of adding latency + noise
-            # to every remaining query.
-            raise SourceUnavailable(f"Unpaywall server error ({r.status_code})")
-        r.raise_for_status()
-        ref = norm_title(title)
-        for res in r.json().get("results") or []:
-            resp = res.get("response", {})
-            if norm_title(resp.get("title", "")) != ref:
-                continue
-            venue = (resp.get("journal_name") or "").strip()
-            if not _is_published_venue(venue):
-                continue
-            doi = resp.get("doi", "")
-            if ARXIV_DOI.match(doi):
-                continue
-            authors = [
-                " ".join(filter(None, [a.get("given"), a.get("family")]))
-                for a in resp.get("z_authors") or []
-            ]
-            _log(f"[unpaywall] match: {venue} {resp.get('year', '')}")
-            return Match(
-                source="unpaywall",
-                venue=venue,
-                title=clean_title(resp.get("title", "")),
-                year=str(resp.get("year") or ""),
-                authors=[a for a in authors if a],
-                doi=doi,
-            )
-    return None
-
-
 # ---------------------------------------------------------------------------
 # OpenAlex (not in PaperMemory; unauthenticated with generous rate limits, so
 # it doubles as the metadata fallback when the arXiv API / S2 are throttled)
@@ -722,9 +728,8 @@ def openalex_search(title: str) -> dict | None:
         if r.status_code == 429:
             raise SourceUnavailable("OpenAlex rate-limited (429)")
         if r.status_code >= 500:
-            # A dead endpoint (Unpaywall search 500s for days at a time)
-            # gets benched for the run instead of adding latency + noise
-            # to every remaining query.
+            # A dead endpoint gets benched for the run instead of adding
+            # latency and noise to every remaining query.
             raise SourceUnavailable(f"OpenAlex server error ({r.status_code})")
         r.raise_for_status()
         ref = norm_title(title)
@@ -829,7 +834,6 @@ CASCADE = (
     ("dblp", lambda t, y, a, au: try_dblp(t, au)),
     ("semanticscholar", lambda t, y, a, au: try_semantic_scholar(t, y, a)),
     ("crossref", lambda t, y, a, au: try_crossref(t)),
-    ("unpaywall", lambda t, y, a, au: try_unpaywall(t)),
     ("openalex", lambda t, y, a, au: try_openalex(t)),
 )
 
@@ -840,8 +844,7 @@ CASCADE = (
 _DISABLED: dict[str, str] = {}
 
 # Only these sources are authoritative enough that losing one taints a miss
-# into "incomplete". Unpaywall flakiness is routine and must not stop
-# "not_found" from ever being trustworthy.
+# into "incomplete".
 # Override with BIBCITE_CORE_SOURCES="dblp,semanticscholar" if one of these
 # is down for days and keeps every verdict incomplete.
 CORE_SOURCES = frozenset(
@@ -880,7 +883,9 @@ def find_published(
     # version (the common case) misses everywhere, and used to pay the *sum* of
     # each source's latency; now the wall-clock is the slowest single source.
     # The first verified hit by CASCADE priority still wins.
-    deadline = time.monotonic() + PUBLICATION_TIMEOUT
+    started = time.monotonic()
+    deadline = started + PUBLICATION_TIMEOUT
+    dblp_deadline = min(deadline, started + 4.0)
     active = [(name, fn) for name, fn in CASCADE if name not in _DISABLED]
     outcomes: dict[str, tuple] = {}
     if active:
@@ -888,7 +893,7 @@ def find_published(
             futures = {
                 pool.submit(
                     _with_deadline,
-                    deadline,
+                    dblp_deadline if name == "dblp" else deadline,
                     fn,
                     title,
                     year,
@@ -940,23 +945,28 @@ def find_published(
         author_hint
         and dblp_outcome is not None
         and dblp_outcome[0] == "miss"
-        and time.monotonic() < deadline
     ):
-        try:
-            m = _with_deadline(deadline, try_dblp_fuzzy, title, author_hint, year)
-            if m:
-                cache.put(cache_key, m.__dict__)
-                return m, "found"
-            clean_misses += 1
-        except TransientSourceError as e:
-            incomplete = True
-            _log(f"[dblp-fuzzy] transient failure for this entry: {e}")
-        except SourceUnavailable as e:
-            _DISABLED["dblp"] = str(e)
-            incomplete = True
-        except Exception as e:
+        if time.monotonic() >= dblp_deadline:
             incomplete = True
-            _log(f"[dblp-fuzzy] error: {type(e).__name__}: {e}")
+            _log("[dblp-fuzzy] skipped: DBLP lookup budget exhausted")
+        else:
+            try:
+                m = _with_deadline(
+                    dblp_deadline, try_dblp_fuzzy, title, author_hint, year
+                )
+                if m:
+                    cache.put(cache_key, m.__dict__)
+                    return m, "found"
+                clean_misses += 1
+            except TransientSourceError as e:
+                incomplete = True
+                _log(f"[dblp-fuzzy] transient failure for this entry: {e}")
+            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}")
     if not clean_misses:
         return None, "unavailable"
     return None, ("incomplete" if incomplete else "not_found")

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/src/bibcite/venues.py

@@ -2,7 +2,7 @@
 
 Parses the vendored ``data/strings.bib`` @string table (journals /
 conferences / workshops) and maps venue strings returned by DBLP, Semantic
-Scholar, CrossRef, Unpaywall, etc. onto the canonical names.
+Scholar, CrossRef, OpenAlex, etc. onto the canonical names.
 """
 
 import re

bibcite_cli-0.6.5/tests/test_dblp.py

@@ -0,0 +1,152 @@
+import httpx
+import pytest
+
+import bibcite.sources as sources
+from bibcite.bibfile import parse_bibtex_entry
+
+
+@pytest.fixture(autouse=True)
+def isolated(monkeypatch):
+    monkeypatch.setattr(sources, "_LAST_REQUEST", {})
+    monkeypatch.setattr(sources.time, "sleep", lambda _: None)
+
+
+def _hit(title="A Published Paper"):
+    return {
+        "info": {
+            "authors": {
+                "author": [
+                    {"text": "Ada Lovelace 0001"},
+                    {"text": "Grace Hopper"},
+                ]
+            },
+            "title": title,
+            "venue": "Test Conference",
+            "year": "2025",
+            "pages": "12-24",
+            "volume": "42",
+            "number": "3",
+            "doi": "10.1000/test",
+            "ee": "https://doi.org/10.1000/test",
+            "url": "https://dblp.org/rec/conf/test/Lovelace25",
+            "key": "conf/test/Lovelace25",
+            "type": "Conference and Workshop Papers",
+            "publisher": "Example Press",
+            "editor": "Test Editor",
+            "isbn": "978-0-00-000000-0",
+        }
+    }
+
+
+@pytest.mark.parametrize("fuzzy", [False, True])
+def test_dblp_match_uses_search_json_without_bib_download(monkeypatch, fuzzy):
+    calls = []
+    query_title = (
+        "An Information-Theoretic Perspective on Variance-Invariance-Covariance Regularization"
+        if fuzzy
+        else "A Published Paper"
+    )
+    hit = _hit(
+        "An Information Theory Perspective on Variance-Invariance-Covariance Regularization"
+        if fuzzy
+        else query_title
+    )
+
+    def get(client, url, params=None):
+        calls.append((url, params))
+        return httpx.Response(
+            200,
+            request=httpx.Request("GET", url),
+            json={"result": {"hits": {"hit": [hit]}}},
+        )
+
+    monkeypatch.setattr(sources, "_dblp_get", get)
+    match = (
+        sources.try_dblp_fuzzy(query_title, "lovelace", "2024")
+        if fuzzy
+        else sources.try_dblp(query_title)
+    )
+
+    assert match is not None
+    assert len(calls) == 1
+    assert calls[0][0].endswith("/search/publ/api")
+    entry = parse_bibtex_entry(match.bibtex)
+    assert entry["ENTRYTYPE"] == "inproceedings"
+    assert entry["author"] == "Ada Lovelace and Grace Hopper"
+    assert entry["title"] == hit["info"]["title"]
+    assert entry["booktitle"] == "Test Conference"
+    for field in (
+        "year",
+        "pages",
+        "volume",
+        "number",
+        "doi",
+        "url",
+        "publisher",
+        "editor",
+        "isbn",
+    ):
+        expected = hit["info"]["ee"] if field == "url" else hit["info"][field]
+        assert entry[field] == expected
+
+
+def test_dblp_json_type_distinguishes_journal_articles():
+    info = _hit()["info"]
+    info.update(
+        {
+            "type": "Journal Articles",
+            "key": "journals/test/Lovelace25",
+            "venue": "Test Journal",
+        }
+    )
+
+    entry = parse_bibtex_entry(sources._dblp_match(info, "dblp").bibtex)
+
+    assert entry["ENTRYTYPE"] == "article"
+    assert entry["journal"] == "Test Journal"
+    assert "booktitle" not in entry
+
+
+@pytest.mark.parametrize(
+    ("record_type", "key", "expected"),
+    [
+        ("Books and Theses", "books/example/Test", "book"),
+        ("Books and Theses", "phd/example/Test", "phdthesis"),
+        ("Parts in Books or Collections", "books/example/TestChapter", "incollection"),
+        ("Editorship", "conf/example/2025", "proceedings"),
+    ],
+)
+def test_search_json_preserves_other_record_types(record_type, key, expected):
+    info = _hit()["info"]
+    info.update(type=record_type, key=key)
+    entry = parse_bibtex_entry(sources._dblp_match(info, "dblp").bibtex)
+    assert entry["ENTRYTYPE"] == expected
+    assert "journal" not in entry
+    if expected == "proceedings":
+        assert entry["editor"] == "Test Editor"
+        assert "author" not in entry
+
+
+def test_dblp_exact_still_rejects_a_different_title(monkeypatch):
+    monkeypatch.setattr(sources, "_dblp_search", lambda *args: [_hit("Other Paper")])
+
+    assert sources.try_dblp("A Published Paper") is None
+
+
+@pytest.mark.parametrize(
+    ("author", "year"),
+    [("different", "2024"), ("lovelace", "2010")],
+)
+def test_dblp_fuzzy_still_requires_author_and_plausible_year(monkeypatch, author, year):
+    drifted = _hit(
+        "An Information Theory Perspective on Variance-Invariance-Covariance Regularization"
+    )
+    monkeypatch.setattr(sources, "_dblp_search", lambda *args: [drifted])
+
+    match = sources.try_dblp_fuzzy(
+        "An Information-Theoretic Perspective on Variance-Invariance-Covariance Regularization",
+        author,
+        year,
+    )
+
+    assert match is None

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/tests/test_no_google_scholar.py

@@ -12,7 +12,7 @@ resolver = importlib.import_module("bibcite.resolve")
 
 
 @pytest.mark.parametrize("operation", ["get", "add", "upgrade"])
-def test_cli_never_queries_google_scholar(operation, monkeypatch, tmp_path, capsys):
+def test_cli_never_queries_removed_sources(operation, monkeypatch, tmp_path, capsys):
     monkeypatch.setattr(cache, "DISABLED", True)
     monkeypatch.setattr(sources, "_DISABLED", {})
     monkeypatch.setattr(
@@ -27,7 +27,7 @@ def test_cli_never_queries_google_scholar(operation, monkeypatch, tmp_path, caps
         ),
     )
     visited = []
-    for name in ("dblp", "semantic_scholar", "crossref", "unpaywall", "openalex"):
+    for name in ("dblp", "semantic_scholar", "crossref", "openalex"):
 
         def miss(*args, source=name):
             visited.append(source)
@@ -59,11 +59,7 @@ def test_cli_never_queries_google_scholar(operation, monkeypatch, tmp_path, caps
         args = ["upgrade", str(path), "--dry-run"]
     cli.main(args)
     json.loads(capsys.readouterr().out)
-    assert set(visited) == {
-        "dblp",
-        "semantic_scholar",
-        "crossref",
-        "unpaywall",
-        "openalex",
-    }
+    assert set(visited) == {"dblp", "semantic_scholar", "crossref", "openalex"}
     assert requests == []
+    assert not hasattr(sources, "try_unpaywall")
+    assert all("scholar.google" not in url and "unpaywall" not in url for url in requests)

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/tests/test_source_retries.py

@@ -35,7 +35,7 @@ class _ReadErrorClient:
         return httpx.Response(200, request=request, json={})
 
 
-def test_paced_get_retries_a_single_read_error():
+def test_paced_get_retries_a_single_read_error_for_other_sources():
     client = _ReadErrorClient(failures=1)
 
     response = sources._paced_get(client, "https://dblp.org/test", "dblp", 0)
@@ -44,15 +44,46 @@ def test_paced_get_retries_a_single_read_error():
     assert client.calls == 2
 
 
+@pytest.mark.parametrize("failure", ["timeout", 500, 429])
+def test_dblp_get_never_retries(failure):
+    class Client:
+        calls = 0
+
+        def get(self, url, params=None, timeout=None):
+            self.calls += 1
+            request = httpx.Request("GET", url)
+            if failure == "timeout":
+                raise httpx.ReadTimeout("slow", request=request)
+            return httpx.Response(failure, request=request)
+
+    client = Client()
+    expected = SourceUnavailable if failure == 429 else TransientSourceError
+    with pytest.raises(expected):
+        sources._dblp_get(client, "https://dblp.org/test")
+    assert client.calls == 1
+
+
+def test_dblp_timeout_has_short_phase_caps(monkeypatch):
+    observed = None
+
+    class Client:
+        def get(self, url, params=None, timeout=None):
+            nonlocal observed
+            observed = timeout
+            return httpx.Response(200, request=httpx.Request("GET", url))
+
+    sources._dblp_get(Client(), "https://dblp.org/test")
+    assert isinstance(observed, httpx.Timeout)
+    assert observed.connect == 1.5
+    assert observed.read == 2.5
+    assert observed.write == 1.0
+    assert observed.pool == 1.0
+
+
 def test_dblp_read_failures_do_not_disable_later_batch_entries(monkeypatch):
     def dblp(title, year, arxiv_id, author_hint):
         if title == "First paper":
-            return sources._paced_get(
-                _ReadErrorClient(failures=3),
-                "https://dblp.org/test",
-                "dblp",
-                0,
-            )
+            return sources._dblp_get(_ReadErrorClient(failures=3), "https://dblp.org/test")
         return Match(source="dblp", venue="TMLR", title=title, year="2025")
 
     monkeypatch.setattr(
@@ -110,6 +141,44 @@ def test_requests_use_only_the_remaining_publication_budget(monkeypatch):
         del sources._REQUEST_DEADLINE.value
 
 
+def test_exact_and_fuzzy_share_one_four_second_dblp_budget(monkeypatch):
+    deadlines = []
+    real_with_deadline = sources._with_deadline
+
+    def capture(deadline, fn, *args):
+        if fn in {exact, fuzzy}:
+            deadlines.append(deadline)
+        return real_with_deadline(deadline, fn, *args)
+
+    def exact(*args):
+        return None
+
+    def fuzzy(*args):
+        return None
+
+    started = sources.time.monotonic()
+    monkeypatch.setattr(sources, "CASCADE", (("dblp", exact),))
+    monkeypatch.setattr(sources, "try_dblp_fuzzy", fuzzy)
+    monkeypatch.setattr(sources, "_with_deadline", capture)
+
+    match, status = find_published("A paper", author_hint="author")
+
+    assert (match, status) == (None, "not_found")
+    assert len(deadlines) == 2
+    assert deadlines[0] == deadlines[1]
+    assert deadlines[0] <= started + 4.01
+
+
+def test_expired_budget_prevents_author_fuzzy_from_claiming_not_found(monkeypatch):
+    clock = iter((0.0, 4.0))
+    monkeypatch.setattr(sources.time, "monotonic", lambda: next(clock, 4.0))
+    monkeypatch.setattr(sources, "CASCADE", (("dblp", lambda *args: None),))
+
+    match, status = find_published("A paper", author_hint="author")
+
+    assert (match, status) == (None, "incomplete")
+
+
 def test_upgrade_retries_dblp_after_previous_entry_read_failures(
     tmp_path, monkeypatch
 ):
@@ -133,12 +202,7 @@ def test_upgrade_retries_dblp_after_previous_entry_read_failures(
 
     def dblp(title, year, arxiv_id, author_hint):
         if title == "First paper":
-            return sources._paced_get(
-                _ReadErrorClient(failures=3),
-                "https://dblp.org/test",
-                "dblp",
-                0,
-            )
+            return sources._dblp_get(_ReadErrorClient(failures=3), "https://dblp.org/test")
         return Match(source="dblp", venue="TMLR", title=title, year="2025")
 
     monkeypatch.setattr(

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/tests/test_status_semantics.py

@@ -43,7 +43,7 @@ def test_core_source_429_taints_verdict(monkeypatch):
     monkeypatch.setattr(
         sources,
         "CASCADE",
-        _cascade(dblp="raise", unpaywall=None, crossref=None),
+        _cascade(dblp="raise", openalex=None, crossref=None),
     )
     match, status = find_published("Some Title", author_hint="smith")
     assert (match, status) == (None, "incomplete")
@@ -59,17 +59,6 @@ def test_previously_disabled_core_source_taints_next_queries(monkeypatch):
     assert (match, status) == (None, "incomplete")
 
 
-def test_noncore_outage_does_not_taint(monkeypatch):
-    # Unpaywall outages are routine; a miss stays trustworthy.
-    monkeypatch.setattr(
-        sources,
-        "CASCADE",
-        _cascade(dblp=None, unpaywall="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")

{bibcite_cli-0.6.4 → bibcite_cli-0.6.5}/uv.lock

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