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

{bibcite_cli-0.6.2 → bibcite_cli-0.6.4}/.github/workflows/publish.yml

@@ -4,6 +4,12 @@ on:
   release:
     types:
       - published
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Release tag to publish
+        required: true
+        type: string
 
 permissions:
   contents: read
@@ -12,11 +18,13 @@ jobs:
   build:
     name: Build and verify distributions
     runs-on: ubuntu-latest
+    env:
+      RELEASE_TAG: ${{ github.event.release.tag_name || inputs.tag }}
     steps:
       - name: Check out the release
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
-          ref: ${{ github.event.release.tag_name }}
+          ref: ${{ env.RELEASE_TAG }}
 
       - name: Install uv and Python
         uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
@@ -26,8 +34,8 @@ jobs:
       - name: Verify the release tag matches the package version
         run: |
           package_version="$(uv version --short)"
-          if [ "${GITHUB_REF_NAME}" != "v${package_version}" ]; then
-            echo "Release tag ${GITHUB_REF_NAME} does not match package version ${package_version}."
+          if [ "${RELEASE_TAG}" != "v${package_version}" ]; then
+            echo "Release tag ${RELEASE_TAG} does not match package version ${package_version}."
             exit 1
           fi
 
@@ -71,4 +79,4 @@ jobs:
           path: dist/
 
       - name: Publish distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: bibcite-cli
-Version: 0.6.2
+Version: 0.6.4
 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,7 +158,8 @@ 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, Google 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, Unpaywall, 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.
 
 Successful published matches are cached at `~/.cache/bibcite/published.json`.
@@ -176,6 +177,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_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. |
 
@@ -211,7 +213,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, Google 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, Unpaywall, and OpenAlex.
 
 ## License
 

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

@@ -145,7 +145,8 @@ 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, Google 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, Unpaywall, 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.
 
 Successful published matches are cached at `~/.cache/bibcite/published.json`.
@@ -163,6 +164,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_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. |
 
@@ -198,7 +200,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, Google 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, Unpaywall, and OpenAlex.
 
 ## License
 

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

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

{bibcite_cli-0.6.2 → bibcite_cli-0.6.4}/src/bibcite/normalize.py

@@ -30,8 +30,7 @@ def mini_hash(s: str, replace: str = "") -> str:
     """PaperMemory's miniHash: lowercase, non-alphanumeric replaced.
 
     When ``replace`` is non-empty, each non-word char maps to one replacement
-    char so string positions are preserved (needed by the Google Scholar
-    parser).
+    char so string positions are preserved.
     """
     if replace:
         return re.sub(r"[^a-z0-9_]", replace, s.lower())

{bibcite_cli-0.6.2 → bibcite_cli-0.6.4}/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 -> Google Scholar -> CrossRef -> Unpaywall.
+DBLP -> Semantic Scholar -> CrossRef -> Unpaywall -> OpenAlex.
 All matchers verify identity via normalized-title equality and reject
 preprint venues (arXiv / CoRR / bioRxiv / ...).
 """
@@ -10,10 +10,12 @@ import html
 import os
 import re
 import sys
+import threading
 import time
 import xml.etree.ElementTree as ET
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
+from urllib.parse import urlsplit
 
 import httpx
 
@@ -30,6 +32,10 @@ BROWSER_UA = (
 # never a false "not published". The arXiv metadata fetch sets its own longer
 # timeout on the request itself, so this does not affect it.
 TIMEOUT = 8.0
+# Publication matching is enrichment on top of a valid arXiv citation. Keep
+# the entire concurrent cascade, including its DBLP title-drift fallback,
+# within an interactive budget instead of letting sequential retries add up.
+PUBLICATION_TIMEOUT = 10.0
 
 PREPRINT_VENUES = re.compile(r"arxiv|corr|biorxiv|medrxiv|chemrxiv|ssrn|preprint", re.I)
 ARXIV_DOI = re.compile(r"^10\.48550/", re.I)
@@ -54,6 +60,112 @@ class TransientSourceError(SourceUnavailable):
     process-wide circuit breaker for later batch entries."""
 
 
+class PublicationTimeout(TransientSourceError):
+    """The total publication-matching budget was exhausted."""
+
+
+_REQUEST_DEADLINE = threading.local()
+
+
+def _request_timeout(cap: float = TIMEOUT) -> float:
+    deadline = getattr(_REQUEST_DEADLINE, "value", None)
+    if deadline is None:
+        return cap
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise PublicationTimeout("publication lookup timed out")
+    return max(0.001, min(cap, remaining))
+
+
+def _get(
+    c: httpx.Client, url: str, *, timeout: float = TIMEOUT, **kwargs
+) -> httpx.Response:
+    """GET directly or route keyless supported APIs through the public service."""
+    public_url = os.environ.get("BIBCITE_PUBLIC_SERVICE_URL")
+    target = urlsplit(url)
+    providers = {
+        "api.openalex.org": "openalex",
+        "api.semanticscholar.org": "semanticscholar",
+        "api.crossref.org": "crossref",
+    }
+    provider = providers.get((target.hostname or "").lower())
+    personal_access = {
+        "openalex": bool(os.environ.get("OPENALEX_API_KEY")),
+        "semanticscholar": bool(
+            os.environ.get("S2_API_KEY")
+            or os.environ.get("SEMANTIC_SCHOLAR_API_KEY")
+        ),
+        "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)
+
+    service = urlsplit(public_url)
+    loopback = service.hostname in {"localhost", "127.0.0.1", "::1"}
+    if (
+        (service.scheme != "https" and not (service.scheme == "http" and loopback))
+        or not service.hostname
+        or service.username is not None
+        or service.password is not None
+        or service.query
+        or service.fragment
+    ):
+        raise SourceUnavailable("BIBCITE_PUBLIC_SERVICE_URL is invalid")
+
+    params = kwargs.get("params") or {}
+    safe_params = {
+        str(key): str(value)
+        for key, value in params.items()
+        if str(key).lower() not in {"api_key", "mailto"}
+    }
+    try:
+        response = c.post(
+            public_url,
+            json={"provider": provider, "path": target.path, "params": safe_params},
+            timeout=_request_timeout(timeout),
+            follow_redirects=False,
+        )
+    except httpx.HTTPError as e:
+        raise SourceUnavailable(
+            f"public literature service unavailable ({type(e).__name__})"
+        ) from e
+    if response.status_code == 404:
+        return response
+    if response.status_code == 429:
+        raise SourceUnavailable("public literature service rate-limited (429)")
+    if response.is_error:
+        raise SourceUnavailable(
+            f"public literature service error ({response.status_code})"
+        )
+    return response
+
+
+def _sleep(delay: float):
+    """Sleep for pacing/backoff without crossing the publication deadline."""
+    deadline = getattr(_REQUEST_DEADLINE, "value", None)
+    if deadline is None:
+        time.sleep(delay)
+        return
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise PublicationTimeout("publication lookup timed out")
+    time.sleep(min(delay, remaining))
+    if delay >= remaining:
+        raise PublicationTimeout("publication lookup timed out")
+
+
+def _with_deadline(deadline: float, fn, *args):
+    previous = getattr(_REQUEST_DEADLINE, "value", None)
+    _REQUEST_DEADLINE.value = deadline
+    try:
+        return fn(*args)
+    finally:
+        if previous is None:
+            del _REQUEST_DEADLINE.value
+        else:
+            _REQUEST_DEADLINE.value = previous
+
+
 def _client(browser: bool = False) -> httpx.Client:
     return httpx.Client(
         headers={"User-Agent": BROWSER_UA if browser else UA},
@@ -129,7 +241,8 @@ def arxiv_api_get(params: dict) -> httpx.Response:
             time.sleep(3 * attempt)
         try:
             with _client() as c:
-                r = c.get(
+                r = _get(
+                    c,
                     "https://export.arxiv.org/api/query",
                     params=params,
                     timeout=30.0,
@@ -198,13 +311,13 @@ def _paced_get(
     for attempt in range(2):
         wait = min_interval - (time.monotonic() - _LAST_REQUEST.get(source, 0.0))
         if wait > 0:
-            time.sleep(wait)
+            _sleep(wait)
         _LAST_REQUEST[source] = time.monotonic()
         try:
-            r = c.get(url, params=params, headers=headers)
+            r = _get(c, url, params=params, headers=headers)
         except httpx.HTTPError as e:  # Retry transport errors once before failing.
             if attempt < 1:
-                time.sleep(1)
+                _sleep(1)
                 continue
             raise TransientSourceError(
                 f"{source} unreachable ({type(e).__name__})"
@@ -218,7 +331,7 @@ def _paced_get(
             # skip this source for the rest of the run.
             retry_after = int(r.headers.get("Retry-After") or 0)
             if attempt < 1 and retry_after <= 2:
-                time.sleep(max(retry_after, 1))
+                _sleep(max(retry_after, 1))
                 continue
             raise SourceUnavailable(f"{source} rate-limited (429)")
         return r
@@ -398,7 +511,7 @@ def arxiv_abs_metadata(arxiv_id: str) -> ArxivMeta | None:
     """Scrape the arxiv.org abs page's Highwire meta tags — the abs pages stay
     up when the export API throttles."""
     with _client(browser=True) as c:
-        r = c.get(f"https://arxiv.org/abs/{arxiv_id}")
+        r = _get(c, f"https://arxiv.org/abs/{arxiv_id}")
         if r.status_code != 200:
             return None
         page = r.text
@@ -483,68 +596,14 @@ def try_semantic_scholar(
     return None
 
 
-# ---------------------------------------------------------------------------
-# Google Scholar (port of PaperMemory's background fetchGSData)
-# ---------------------------------------------------------------------------
-
-def try_google_scholar(title: str) -> Match | None:
-    with _client(browser=True) as c:
-        r = c.get(
-            "https://scholar.google.com/scholar",
-            params={"q": title, "hl": "en"},
-        )
-        if r.status_code == 429 or "captcha" in r.text.lower()[:5000]:
-            raise SourceUnavailable("Google Scholar is blocking requests (captcha/429)")
-        r.raise_for_status()
-        parts = r.text.split("gs_res_ccl_mid")
-        if len(parts) < 2:
-            return None
-        page = parts[1]
-        # Each result title anchor looks like <a id="DATAID" href=...>Title</a>
-        # (the title may contain <b> highlights and HTML entities).
-        data_id = ""
-        for am in re.finditer(
-            r'<a[^>]*\bid="([\w-]{6,40})"[^>]*>(.*?)</a>', page, re.S
-        ):
-            text = html.unescape(re.sub(r"<[^>]+>", "", am.group(2)))
-            if norm_title(text) == norm_title(title):
-                data_id = am.group(1)
-                break
-        if not data_id:
-            return None
-        cite_url = (
-            "https://scholar.google.com/scholar?q=info:"
-            f"{data_id}:scholar.google.com/&output=cite&scirp=0&hl=en"
-        )
-        cite_html = c.get(cite_url).text
-        bm = re.search(r'<a[^>]*href="([^">]+)"[^>]*>BibTex</a>', cite_html, re.I)
-        if not bm:
-            return None
-        bib_url = re.sub(r"\s+", "", bm.group(1).replace("&amp;", "&"))
-        bibtex = c.get(bib_url).text
-    from .bibfile import parse_bibtex_entry  # local import to avoid cycle
-
-    entry = parse_bibtex_entry(bibtex)
-    venue = entry.get("journal", "") or entry.get("booktitle", "")
-    if venue and not venue.lower().endswith("xiv") and "preprint" not in venue.lower():
-        _log(f"[googlescholar] match: {venue}")
-        return Match(
-            source="googlescholar",
-            venue=venue,
-            title=clean_title(entry.get("title", title)),
-            year=entry.get("year", ""),
-            bibtex=bibtex,
-        )
-    return None
-
-
 # ---------------------------------------------------------------------------
 # CrossRef
 # ---------------------------------------------------------------------------
 
 def try_crossref(title: str) -> Match | None:
     with _client() as c:
-        r = c.get(
+        r = _get(
+            c,
             "https://api.crossref.org/works",
             params={
                 "rows": 3,
@@ -583,8 +642,9 @@ def try_crossref(title: str) -> Match | None:
                 year = str(parts[0][0])
             bibtex = ""
             if doi:
-                br = c.get(
-                    f"https://api.crossref.org/works/{doi}/transform/application/x-bibtex"
+                br = _get(
+                    c,
+                    f"https://api.crossref.org/works/{doi}/transform/application/x-bibtex",
                 )
                 if br.status_code == 200:
                     bibtex = br.text
@@ -606,7 +666,8 @@ def try_crossref(title: str) -> Match | None:
 
 def try_unpaywall(title: str) -> Match | None:
     with _client() as c:
-        r = c.get(
+        r = _get(
+            c,
             "https://api.unpaywall.org/v2/search",
             params={"query": title, "is_oa": "true", "email": _mailto()},
         )
@@ -653,7 +714,8 @@ def try_unpaywall(title: str) -> Match | None:
 def openalex_search(title: str) -> dict | None:
     """OpenAlex work with an exactly-matching normalized title, or None."""
     with _client() as c:
-        r = c.get(
+        r = _get(
+            c,
             "https://api.openalex.org/works",
             params=_openalex_params({"search": title, "per-page": 5}),
         )
@@ -725,7 +787,9 @@ def try_openalex(title: str) -> Match | None:
 
 def crossref_by_doi(doi: str) -> Match | None:
     with _client() as c:
-        r = c.get(f"https://api.crossref.org/works/{doi}", params={"mailto": _mailto()})
+        r = _get(
+            c, f"https://api.crossref.org/works/{doi}", params={"mailto": _mailto()}
+        )
         if r.status_code != 200:
             return None
         data = r.json().get("message", {})
@@ -737,7 +801,9 @@ def crossref_by_doi(doi: str) -> Match | None:
         if parts and parts[0]:
             year = str(parts[0][0])
         bibtex = ""
-        br = c.get(f"https://api.crossref.org/works/{doi}/transform/application/x-bibtex")
+        br = _get(
+            c, f"https://api.crossref.org/works/{doi}/transform/application/x-bibtex"
+        )
         if br.status_code == 200:
             bibtex = br.text
         authors = [
@@ -762,7 +828,6 @@ def crossref_by_doi(doi: str) -> Match | None:
 CASCADE = (
     ("dblp", lambda t, y, a, au: try_dblp(t, au)),
     ("semanticscholar", lambda t, y, a, au: try_semantic_scholar(t, y, a)),
-    ("googlescholar", lambda t, y, a, au: try_google_scholar(t)),
     ("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)),
@@ -775,8 +840,8 @@ CASCADE = (
 _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.
+# into "incomplete". Unpaywall flakiness is routine and must not stop
+# "not_found" from ever being trustworthy.
 # Override with BIBCITE_CORE_SOURCES="dblp,semanticscholar" if one of these
 # is down for days and keeps every verdict incomplete.
 CORE_SOURCES = frozenset(
@@ -815,12 +880,21 @@ 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
     active = [(name, fn) for name, fn in CASCADE if name not in _DISABLED]
     outcomes: dict[str, tuple] = {}
     if active:
         with ThreadPoolExecutor(max_workers=len(active)) as pool:
             futures = {
-                pool.submit(fn, title, year, arxiv_id, author_hint): name
+                pool.submit(
+                    _with_deadline,
+                    deadline,
+                    fn,
+                    title,
+                    year,
+                    arxiv_id,
+                    author_hint,
+                ): name
                 for name, fn in active
             }
             for future in as_completed(futures):
@@ -858,9 +932,18 @@ def find_published(
     # Exact-title search missed everywhere. Before concluding "no published
     # version", try the title-drift fallback — camera-ready titles frequently
     # differ from the arXiv ones, which is precisely the upgrade scenario.
-    if author_hint and "dblp" not in _DISABLED:
+    # Only a clean exact DBLP miss justifies another query. A timeout or other
+    # failure has already spent its chance for this entry, and retrying the
+    # fuzzy form was doubling the worst-case interactive latency.
+    dblp_outcome = outcomes.get("dblp")
+    if (
+        author_hint
+        and dblp_outcome is not None
+        and dblp_outcome[0] == "miss"
+        and time.monotonic() < deadline
+    ):
         try:
-            m = try_dblp_fuzzy(title, author_hint, year)
+            m = _with_deadline(deadline, try_dblp_fuzzy, title, author_hint, year)
             if m:
                 cache.put(cache_key, m.__dict__)
                 return m, "found"
@@ -920,7 +1003,7 @@ def fetch_web_page(url: str) -> WebPage:
     """
     try:
         with _client(browser=True) as client:
-            response = client.get(url)
+            response = _get(client, url)
             response.raise_for_status()
             body = response.text[:400_000]
     except httpx.HTTPStatusError as e:

{bibcite_cli-0.6.2 → bibcite_cli-0.6.4}/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, Google Scholar, CrossRef, Unpaywall, etc. onto the canonical names.
+Scholar, CrossRef, Unpaywall, etc. onto the canonical names.
 """
 
 import re

bibcite_cli-0.6.4/tests/test_no_google_scholar.py

@@ -0,0 +1,69 @@
+"""Exercise the CLI publication cascade without contacting external services."""
+
+import importlib
+import json
+
+import httpx
+import pytest
+
+from bibcite import cache, cli, sources
+
+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):
+    monkeypatch.setattr(cache, "DISABLED", True)
+    monkeypatch.setattr(sources, "_DISABLED", {})
+    monkeypatch.setattr(
+        resolver,
+        "arxiv_metadata",
+        lambda _: sources.ArxivMeta(
+            "1706.03762",
+            "Attention Is All You Need",
+            ["Ashish Vaswani"],
+            "2017",
+            "https://arxiv.org/abs/1706.03762",
+        ),
+    )
+    visited = []
+    for name in ("dblp", "semantic_scholar", "crossref", "unpaywall", "openalex"):
+
+        def miss(*args, source=name):
+            visited.append(source)
+            return None
+
+        monkeypatch.setattr(sources, f"try_{name}", miss)
+    monkeypatch.setattr(sources, "try_dblp_fuzzy", lambda *args: None)
+    requests = []
+
+    def unexpected_request(client, url, **kwargs):
+        requests.append(url)
+        return httpx.Response(429, request=httpx.Request("GET", url))
+
+    monkeypatch.setattr(sources, "_get", unexpected_request)
+    path = tmp_path / "references.bib"
+    if operation == "get":
+        args = ["get", "--json", "1706.03762"]
+    elif operation == "add":
+        args = ["add", "--no-tidy", str(path), "1706.03762"]
+    else:
+        path.write_text("""@article{vaswani2017attention,
+  title = {Attention Is All You Need},
+  author = {Ashish Vaswani},
+  year = {2017},
+  journal = {arXiv preprint arXiv:1706.03762},
+  eprint = {1706.03762}
+}
+""")
+        args = ["upgrade", str(path), "--dry-run"]
+    cli.main(args)
+    json.loads(capsys.readouterr().out)
+    assert set(visited) == {
+        "dblp",
+        "semantic_scholar",
+        "crossref",
+        "unpaywall",
+        "openalex",
+    }
+    assert requests == []

bibcite_cli-0.6.4/tests/test_public_service.py

@@ -0,0 +1,188 @@
+import json
+
+import httpx
+import pytest
+
+from bibcite import sources
+
+
+@pytest.fixture(autouse=True)
+def clean_environment(monkeypatch):
+    for name in (
+        "BIBCITE_PUBLIC_SERVICE_URL",
+        "BIBCITE_MAILTO",
+        "OPENALEX_API_KEY",
+        "S2_API_KEY",
+        "SEMANTIC_SCHOLAR_API_KEY",
+    ):
+        monkeypatch.delenv(name, raising=False)
+    monkeypatch.setattr(sources, "_LAST_REQUEST", {})
+    monkeypatch.setattr(sources.time, "sleep", lambda _: None)
+
+
+def _client(handler):
+    return httpx.Client(transport=httpx.MockTransport(handler))
+
+
+@pytest.mark.parametrize(
+    ("url", "provider", "path"),
+    (
+        ("https://api.openalex.org/works", "openalex", "/works"),
+        (
+            "https://api.semanticscholar.org/graph/v1/paper/search",
+            "semanticscholar",
+            "/graph/v1/paper/search",
+        ),
+        (
+            "https://api.crossref.org/works/10.1234/example/transform/application/x-bibtex",
+            "crossref",
+            "/works/10.1234/example/transform/application/x-bibtex",
+        ),
+    ),
+)
+def test_keyless_supported_requests_route_to_public_service(
+    url, provider, path, monkeypatch
+):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", "https://literature.test/v1/query")
+    requests = []
+
+    def handler(request):
+        requests.append(request)
+        return httpx.Response(200, json={"unchanged": True})
+
+    with _client(handler) as client:
+        response = sources._get(
+            client,
+            url,
+            params={
+                "query": "paper",
+                "limit": 5,
+                "api_key": "secret",
+                "mailto": "secret@example.com",
+            },
+            headers={"x-api-key": "secret"},
+        )
+
+    assert response.json() == {"unchanged": True}
+    assert len(requests) == 1
+    request = requests[0]
+    assert request.method == "POST"
+    assert request.url == "https://literature.test/v1/query"
+    assert "x-api-key" not in request.headers
+    payload = json.loads(request.content)
+    assert payload == {
+        "provider": provider,
+        "path": path,
+        "params": {"query": "paper", "limit": "5"},
+    }
+    assert "secret" not in request.content.decode()
+
+
+@pytest.mark.parametrize(
+    ("variable", "url", "params"),
+    (
+        ("OPENALEX_API_KEY", "https://api.openalex.org/works", {"api_key": "mine"}),
+        ("S2_API_KEY", "https://api.semanticscholar.org/graph/v1/paper/search", {}),
+        (
+            "BIBCITE_MAILTO",
+            "https://api.crossref.org/works",
+            {"mailto": "me@example.com"},
+        ),
+    ),
+)
+def test_personal_access_overrides_public_service(variable, url, params, monkeypatch):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", "https://literature.test/v1/query")
+    monkeypatch.setenv(variable, "mine")
+    requests = []
+
+    def handler(request):
+        requests.append(request)
+        return httpx.Response(200, json={})
+
+    with _client(handler) as client:
+        sources._get(client, url, params=params)
+
+    assert len(requests) == 1
+    assert requests[0].method == "GET"
+    assert requests[0].url.host != "literature.test"
+
+
+def test_without_public_service_requests_remain_direct():
+    requests = []
+
+    def handler(request):
+        requests.append(request)
+        return httpx.Response(200, json={})
+
+    with _client(handler) as client:
+        sources._get(client, "https://api.openalex.org/works", params={"search": "x"})
+
+    assert len(requests) == 1
+    assert requests[0].method == "GET"
+    assert requests[0].url.host == "api.openalex.org"
+
+
+@pytest.mark.parametrize("status", [429, 500])
+def test_public_service_http_failure_is_not_retried(status, monkeypatch):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", "https://literature.test/v1/query")
+    calls = 0
+
+    def handler(request):
+        nonlocal calls
+        calls += 1
+        return httpx.Response(status)
+
+    with _client(handler) as client, pytest.raises(sources.SourceUnavailable):
+        sources._paced_get(
+            client,
+            "https://api.semanticscholar.org/graph/v1/paper/search",
+            "semanticscholar",
+            0,
+        )
+
+    assert calls == 1
+
+
+def test_public_service_timeout_is_not_retried(monkeypatch):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", "https://literature.test/v1/query")
+    calls = 0
+
+    def handler(request):
+        nonlocal calls
+        calls += 1
+        raise httpx.ReadTimeout("timed out", request=request)
+
+    with _client(handler) as client, pytest.raises(sources.SourceUnavailable):
+        sources._paced_get(
+            client,
+            "https://api.semanticscholar.org/graph/v1/paper/search",
+            "semanticscholar",
+            0,
+        )
+
+    assert calls == 1
+
+
+def test_public_service_404_is_preserved(monkeypatch):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", "https://literature.test/v1/query")
+
+    with _client(lambda request: httpx.Response(404)) as client:
+        response = sources._get(client, "https://api.openalex.org/works/W1")
+
+    assert response.status_code == 404
+
+
+@pytest.mark.parametrize(
+    "value",
+    (
+        "http://literature.test/v1/query",
+        "https://user:pass@literature.test/v1/query",
+        "https://literature.test/v1/query?secret=x",
+        "https://literature.test/v1/query#fragment",
+    ),
+)
+def test_invalid_public_service_url_is_rejected(value, monkeypatch):
+    monkeypatch.setenv("BIBCITE_PUBLIC_SERVICE_URL", value)
+    with _client(lambda request: httpx.Response(200)) as client:
+        with pytest.raises(sources.SourceUnavailable):
+            sources._get(client, "https://api.openalex.org/works")

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

@@ -5,7 +5,12 @@ import bibcite.sources as sources
 from bibcite import cache
 from bibcite.bibfile import load_bib_file
 from bibcite.cli import _upgrade_entries
-from bibcite.sources import Match, SourceUnavailable, find_published
+from bibcite.sources import (
+    Match,
+    SourceUnavailable,
+    TransientSourceError,
+    find_published,
+)
 
 
 @pytest.fixture(autouse=True)
@@ -22,7 +27,7 @@ class _ReadErrorClient:
         self.failures = failures
         self.calls = 0
 
-    def get(self, url, params=None, headers=None):
+    def get(self, url, params=None, headers=None, timeout=None):
         self.calls += 1
         request = httpx.Request("GET", url, params=params, headers=headers)
         if self.calls <= self.failures:
@@ -70,6 +75,41 @@ def test_dblp_read_failures_do_not_disable_later_batch_entries(monkeypatch):
     assert second_match.venue == "TMLR"
 
 
+def test_dblp_transport_failure_skips_the_fuzzy_retry(monkeypatch):
+    fuzzy_calls = 0
+
+    def dblp(*args):
+        raise TransientSourceError("simulated timeout")
+
+    def fuzzy(*args):
+        nonlocal fuzzy_calls
+        fuzzy_calls += 1
+
+    monkeypatch.setattr(
+        sources,
+        "CASCADE",
+        (
+            ("dblp", dblp),
+            ("crossref", lambda *args: None),
+        ),
+    )
+    monkeypatch.setattr(sources, "try_dblp_fuzzy", fuzzy)
+
+    match, status = find_published("First paper", author_hint="doe")
+
+    assert (match, status) == (None, "incomplete")
+    assert fuzzy_calls == 0
+
+
+def test_requests_use_only_the_remaining_publication_budget(monkeypatch):
+    monkeypatch.setattr(sources.time, "monotonic", lambda: 7.0)
+    sources._REQUEST_DEADLINE.value = 10.0
+    try:
+        assert sources._request_timeout(8.0) == 3.0
+    finally:
+        del sources._REQUEST_DEADLINE.value
+
+
 def test_upgrade_retries_dblp_after_previous_entry_read_failures(
     tmp_path, monkeypatch
 ):

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

@@ -43,7 +43,7 @@ def test_core_source_429_taints_verdict(monkeypatch):
     monkeypatch.setattr(
         sources,
         "CASCADE",
-        _cascade(dblp="raise", googlescholar=None, crossref=None),
+        _cascade(dblp="raise", unpaywall=None, crossref=None),
     )
     match, status = find_published("Some Title", author_hint="smith")
     assert (match, status) == (None, "incomplete")
@@ -60,11 +60,11 @@ def test_previously_disabled_core_source_taints_next_queries(monkeypatch):
 
 
 def test_noncore_outage_does_not_taint(monkeypatch):
-    # Google Scholar captcha is routine; a miss stays trustworthy.
+    # Unpaywall outages are routine; a miss stays trustworthy.
     monkeypatch.setattr(
         sources,
         "CASCADE",
-        _cascade(dblp=None, googlescholar="raise", crossref=None),
+        _cascade(dblp=None, unpaywall="raise", crossref=None),
     )
     match, status = find_published("Some Title", author_hint="smith")
     assert (match, status) == (None, "not_found")

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

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