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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "bibcite-cli"
-version = "0.6.4"
+version = "0.6.6"
 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.6}/src/bibcite/sources.py

@@ -1,12 +1,13 @@
 """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 / ...).
 """
 
 import html
+import json
 import os
 import re
 import sys
@@ -19,7 +20,14 @@ from urllib.parse import urlsplit
 
 import httpx
 
-from .normalize import clean_title, mini_hash, norm_title, sig_tokens, titles_similar
+from .normalize import (
+    clean_title,
+    first_author_last_name,
+    mini_hash,
+    norm_title,
+    sig_tokens,
+    titles_similar,
+)
 
 UA = "bibcite/0.6 (https://github.com/leo1oel/bibcite)"
 BROWSER_UA = (
@@ -78,7 +86,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 +110,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 +198,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,73 +355,216 @@ 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:
-    """DBLP's search parser 500s deterministically on queries containing its
-    syntax characters (':' in subtitled papers, '?' in question titles).
-    They tokenize on punctuation anyway, so replacing with spaces loses
-    nothing."""
-    return re.sub(r"[^\w\s.-]", " ", q)
 
+def _dblp_title_search(c: httpx.Client, title: str) -> list:
+    """Indexed title candidates, not a full-dataset regex or a retry cascade.
 
-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."""
-    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 []
+    QLever's literal text index avoids the slow CompleteSearch endpoint.
+    The caller still verifies the entire normalized title and author identity.
+    Limit publications BEFORE expanding author signatures, otherwise a paper
+    with many authors can silently lose authors or crowd out the actual match.
+    """
+    tokens = sorted(
+        set(re.findall(r"[^\W_]+", title.lower())), key=lambda t: (-len(t), t)
+    )[:5]
+    if not tokens:
+        raise TransientSourceError("dblp title has no searchable words")
+    words = json.dumps(" ".join(tokens), ensure_ascii=False)
+    query = f"""PREFIX dblp: <https://dblp.org/rdf/schema#>
+PREFIX ql: <http://qlever.cs.uni-freiburg.de/builtin-functions/>
+SELECT ?publ ?subject ?predicate ?value WHERE {{
+  {{ SELECT DISTINCT ?publ ?title WHERE {{
+    ?text ql:contains-word {words} ; ql:contains-entity ?title .
+    ?publ dblp:title ?title .
+  }} ORDER BY STRLEN(STR(?title)) ?publ LIMIT 101 }}
+  ?publ dblp:hasSignature? ?subject .
+  ?subject ?predicate ?value .
+}}"""
+    response = _dblp_get(
+        c,
+        "https://sparql.dblp.org/sparql",
+        params={"query": query, "action": "sparql_json_export"},
+    )
+    response.raise_for_status()
+    # Do not turn an HTML challenge or malformed/partial response into a clean miss.
+    rows = response.json()["results"]["bindings"]
+    # Read the bounded publication/signature triples instead of joining every
+    # optional field with every author. Those joins made live queries ~5s;
+    # this indexed property path returns the same fields without a cross product.
+    records: dict[str, dict[str, dict[str, list[str]]]] = {}
+    for row in rows:
+        values = {key: value["value"] for key, value in row.items()}
+        url = values["publ"]
+        if not url.startswith("https://dblp.org/rec/"):
+            raise TransientSourceError(
+                "dblp returned an invalid publication identifier"
+            )
+        subject = records.setdefault(url, {}).setdefault(values["subject"], {})
+        subject.setdefault(values["predicate"].rsplit("#", 1)[-1], []).append(
+            values["value"]
+        )
+    kinds = {
+        "Article": "Journal Articles",
+        "Inproceedings": "Conference and Workshop Papers",
+        "Incollection": "Parts in Books or Collections",
+        "Book": "Books and Theses",
+        "Editorship": "Editorship",
+        "Informal": "Informal and Other Publications",
+        "Reference": "Parts in Books or Collections",
+    }
+    fields = {
+        "title": "title",
+        "yearOfPublication": "year",
+        "publishedIn": "venue",
+        "pagination": "pages",
+        "publishedInJournalVolume": "volume",
+        "publishedInJournalVolumeIssue": "number",
+        "publishedBy": "publisher",
+        "primaryDocumentPage": "ee",
+    }
+    hits = []
+    for url, subjects in records.items():
+        record = subjects[url]
+        info = {
+            target: record[prop][0]
+            for prop, target in fields.items()
+            if record.get(prop)
+        }
+        info.update(url=url, key=url.removeprefix("https://dblp.org/rec/"))
+        for kind in record.get("type", []):
+            if kind.rsplit("#", 1)[-1] in kinds:
+                info["type"] = kinds[kind.rsplit("#", 1)[-1]]
+        if record.get("doi"):
+            info["doi"] = record["doi"][0].removeprefix("https://doi.org/")
+        if record.get("isbn"):
+            info["isbn"] = record["isbn"][0].removeprefix("urn:isbn:")
+        if not info.get("ee") and record.get("documentPage"):
+            info["ee"] = record["documentPage"][0]
+        authors, editors = [], []
+        for signature in record.get("hasSignature", []):
+            data = subjects[signature]
+            name = data["signatureDblpName"][0]
+            ordinal = int(data["signatureOrdinal"][0])
+            target = (
+                editors
+                if any(t.endswith("#EditorSignature") for t in data.get("type", []))
+                else authors
+            )
+            target.append((ordinal, name))
+        info["authors"] = {"author": [{"text": name} for _, name in sorted(authors)]}
+        info["editor"] = " and ".join(name for _, name in sorted(editors))
+        hits.append({"info": info})
+    return hits
+
+
+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
-    first, then fall back to the bare title."""
-    queries = []
-    if author_hint:
-        queries.append(f"{title} {author_hint}")
-    queries.append(title)
+    """One SPARQL title lookup; failures never start another network attempt."""
     with _client() as c:
-        for q in queries:
-            hits = _dblp_search(c, q)
-            # Earliest year first: prefer the original conference publication
-            # over later journal extensions (same heuristic as PaperMemory).
-            hits.sort(key=lambda h: int(h.get("info", {}).get("year", 9999)))
-            ref = norm_title(title)
-            for hit in hits:
-                info = hit.get("info", {})
-                if norm_title(html.unescape(info.get("title", ""))) != ref:
-                    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
-                _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", ""),
-                )
+        hits = _dblp_title_search(c, title)
+    # Prefer the original conference publication over later journal extensions.
+    hits.sort(key=lambda h: int(h.get("info", {}).get("year", 9999)))
+    ref = norm_title(title)
+    for hit in hits:
+        info = hit.get("info", {})
+        if norm_title(html.unescape(info.get("title", ""))) != ref:
+            continue
+        if not info.get("type") or info["type"] == "Informal and Other Publications":
+            continue
+        if not _is_published_venue(str(info.get("venue", ""))):
+            continue
+        authors = _dblp_hit_authors(info)
+        if author_hint and not any(
+            mini_hash(author_hint) == first_author_last_name(name) for name in authors
+        ):
+            continue
+        match = _dblp_match(info, "dblp")
+        _log(f"[dblp] match: {match.venue} {info.get('year', '')}")
+        return match
+    if len(hits) >= 101:
+        raise TransientSourceError("dblp title candidate window exceeded")
     return None
 
 
@@ -414,62 +572,58 @@ 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:
     """Title-drift fallback: camera-ready titles often differ from the arXiv
     ones ("Information-Theoretic" -> "Information Theory"), and DBLP's
-    token-AND search then misses entirely. Query author + the most
-    distinctive title tokens instead, and accept token-Jaccard-similar
+    token-AND search then misses entirely. Query the most distinctive
+    title tokens instead, and accept token-Jaccard-similar
     titles — guarded by author and year so different papers can't sneak in.
     """
     if not author_hint:
         return None
-    tokens = sorted(sig_tokens(title), key=len, reverse=True)[:3]
+    tokens = sorted(sig_tokens(title), key=lambda t: (-len(t), t))[:3]
     if not tokens:
         return None
-    q = " ".join([author_hint] + tokens)
+    q = " ".join(tokens)
     with _client() as c:
-        hits = _dblp_search(c, q)
+        hits = _dblp_title_search(c, q)
         hits.sort(key=lambda h: int(h.get("info", {}).get("year", 9999)))
         for hit in hits:
             info = hit.get("info", {})
             hit_title = clean_title(html.unescape(info.get("title", "")))
-            if info.get("venue") == "CoRR" or not info.get("venue"):
+            if (
+                not info.get("type")
+                or info["type"] == "Informal and Other Publications"
+            ):
+                continue
+            if not _is_published_venue(str(info.get("venue", ""))):
                 continue
             if not titles_similar(hit_title, title):
                 continue
             if year and info.get("year"):
                 if abs(int(info["year"]) - int(year)) > 2:
                     continue
-            hit_authors = mini_hash(" ".join(_dblp_hit_authors(info)))
-            if author_hint not in hit_authors:
+            if not any(
+                mini_hash(author_hint) == first_author_last_name(name)
+                for name in _dblp_hit_authors(info)
+            ):
                 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
+    if len(hits) >= 101:
+        raise TransientSourceError("dblp title candidate window exceeded")
     return None
 
 
@@ -615,9 +769,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 +813,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 +829,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 +935,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 +945,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 +984,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 +994,7 @@ def find_published(
             futures = {
                 pool.submit(
                     _with_deadline,
-                    deadline,
+                    dblp_deadline if name == "dblp" else deadline,
                     fn,
                     title,
                     year,
@@ -940,23 +1046,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)
+        if time.monotonic() >= dblp_deadline:
             incomplete = True
-        except Exception as e:
-            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.6}/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.6/tests/test_dblp.py

@@ -0,0 +1,266 @@
+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)
+    monkeypatch.setattr(sources, "_dblp_title_search", lambda *args: [hit])
+    match = (
+        sources.try_dblp_fuzzy(query_title, "lovelace", "2024")
+        if fuzzy
+        else sources.try_dblp(query_title)
+    )
+
+    assert match is not None
+    assert calls == []
+    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_title_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_title_search", lambda *args: [drifted])
+
+    match = sources.try_dblp_fuzzy(
+        "An Information-Theoretic Perspective on Variance-Invariance-Covariance Regularization",
+        author,
+        year,
+    )
+
+    assert match is None
+
+
+def _triples(key="conf/test/Lovelace25", title="A Published Paper."):
+    prefix = "https://dblp.org/rdf/schema#"
+    url = "https://dblp.org/rec/" + key
+    triples = [
+        (url, "title", title),
+        (url, "yearOfPublication", "2025"),
+        (url, "publishedIn", "Test Conference"),
+        (url, "type", prefix + "Inproceedings"),
+        (url, "type", prefix + "Publication"),
+        (url, "pagination", "12-24"),
+        (url, "primaryDocumentPage", "https://example.org/paper"),
+        (url, "publishedInJournalVolume", "42"),
+        (url, "publishedInJournalVolumeIssue", "3"),
+        (url, "publishedBy", "Example Press"),
+        (url, "doi", "https://doi.org/10.1000/test"),
+        (url, "hasSignature", "s2"),
+        (url, "hasSignature", "s1"),
+        ("s2", "signatureDblpName", "Grace Hopper"),
+        ("s2", "signatureOrdinal", "2"),
+        ("s2", "type", prefix + "AuthorSignature"),
+        ("s1", "signatureDblpName", "Ada Lovelace 0001"),
+        ("s1", "signatureOrdinal", "1"),
+        ("s1", "type", prefix + "AuthorSignature"),
+    ]
+    return [
+        {
+            k: {"type": "literal", "value": v}
+            for k, v in {
+                "publ": url,
+                "subject": subject,
+                "predicate": prefix + predicate,
+                "value": value,
+            }.items()
+        }
+        for subject, predicate, value in triples
+    ]
+
+
+def test_sparql_returns_complete_ordered_authors_in_one_request(monkeypatch):
+    calls = []
+
+    def get(client, url, params=None):
+        calls.append((url, params))
+        return httpx.Response(
+            200,
+            request=httpx.Request("GET", url),
+            json={"results": {"bindings": _triples()}},
+        )
+
+    monkeypatch.setattr(sources, "_dblp_get", get)
+    match = sources.try_dblp("A Published Paper", "lovelace")
+    assert match is not None
+    assert match.authors == ["Ada Lovelace", "Grace Hopper"]
+    assert match.doi == "10.1000/test"
+    entry = parse_bibtex_entry(match.bibtex)
+    assert entry["pages"] == "12-24"
+    assert entry["url"] == "https://example.org/paper"
+    assert entry["volume"] == "42"
+    assert entry["number"] == "3"
+    assert entry["publisher"] == "Example Press"
+    assert entry["ENTRYTYPE"] == "inproceedings"
+    assert len(calls) == 1
+    assert calls[0][0] == "https://sparql.dblp.org/sparql"
+    assert "LIMIT 101" in calls[0][1]["query"]
+    assert "dblp:hasSignature?" in calls[0][1]["query"]
+
+
+@pytest.mark.parametrize("author", ["different", "lace"])
+def test_sparql_exact_checks_author_not_substring(monkeypatch, author):
+    monkeypatch.setattr(sources, "_dblp_title_search", lambda *args: [_hit()])
+    assert sources.try_dblp("A Published Paper", author) is None
+
+
+def test_sparql_overflow_is_incomplete_not_a_clean_miss(monkeypatch):
+    monkeypatch.setattr(
+        sources, "_dblp_title_search", lambda *args: [_hit("Other")] * 101
+    )
+    with pytest.raises(sources.TransientSourceError, match="window exceeded"):
+        sources.try_dblp("A Published Paper")
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [{}, {"results": {}}, {"results": {"bindings": [{"publ": {"value": "bad"}}]}}],
+)
+def test_sparql_malformed_data_does_not_become_a_clean_miss(monkeypatch, payload):
+    monkeypatch.setattr(
+        sources,
+        "_dblp_get",
+        lambda c, url, params=None: httpx.Response(
+            200,
+            request=httpx.Request("GET", url),
+            json=payload,
+        ),
+    )
+    with pytest.raises((KeyError, sources.TransientSourceError)):
+        sources.try_dblp("A Published Paper")
+
+
+def test_sparql_timeout_does_not_retry_search_endpoint(monkeypatch):
+    calls = []
+
+    def get(client, url, params=None):
+        calls.append(url)
+        raise sources.TransientSourceError("timeout")
+
+    monkeypatch.setattr(sources, "_dblp_get", get)
+    with pytest.raises(sources.TransientSourceError):
+        sources.try_dblp("A Published Paper")
+    assert calls == ["https://sparql.dblp.org/sparql"]

{bibcite_cli-0.6.4 → bibcite_cli-0.6.6}/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.6}/tests/test_round3.py

@@ -86,9 +86,22 @@ def test_scrub_leaves_clean_files_alone(tmp_path: Path):
     assert bib.read_text() == original  # untouched, not even rewritten
 
 
-def test_dblp_sanitize_strips_syntax_chars():
-    from bibcite.sources import _dblp_sanitize
-
-    q = _dblp_sanitize("LeJEPA: Provable? Self-Supervised (Learning)")
-    assert ":" not in q and "?" not in q and "(" not in q
-    assert "Self-Supervised" in q  # hyphens survive
+def test_dblp_query_does_not_interpret_title_as_sparql(monkeypatch):
+    import httpx
+    from bibcite import sources
+
+    queries = []
+
+    def get(client, url, params=None):
+        queries.append(params["query"])
+        return httpx.Response(
+            200, request=httpx.Request("GET", url), json={"results": {"bindings": []}}
+        )
+
+    monkeypatch.setattr(sources, "_dblp_get", get)
+    with sources._client() as client:
+        sources._dblp_title_search(
+            client, 'LeJEPA: Provable? Self-Supervised (Learning) " } #'
+        )
+    assert '"supervised learning provable lejepa self"' in queries[0]
+    assert '#"' not in queries[0]

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

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