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

{bibcite_cli-0.6.3 → 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.3 → bibcite_cli-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bibcite-cli
-Version: 0.6.3
+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.3 → 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.3 → bibcite_cli-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bibcite-cli"
-version = "0.6.3"
+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.3 → 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.3 → 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 / ...).
 """
@@ -15,6 +15,7 @@ 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
 
@@ -79,8 +80,64 @@ def _request_timeout(cap: float = TIMEOUT) -> float:
 def _get(
     c: httpx.Client, url: str, *, timeout: float = TIMEOUT, **kwargs
 ) -> httpx.Response:
-    """GET with the per-request cap narrowed by the active total deadline."""
-    return c.get(url, timeout=_request_timeout(timeout), **kwargs)
+    """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):
@@ -539,62 +596,6 @@ 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 = _get(
-            c,
-            "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 = _get(c, 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 = _get(c, 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
 # ---------------------------------------------------------------------------
@@ -827,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)),
@@ -840,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(

{bibcite_cli-0.6.3 → 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.3 → 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.3 → bibcite_cli-0.6.4}/uv.lock

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