bibcite-cli 0.1.0__py3-none-any.whl

bibcite/venues.py

@@ -0,0 +1,241 @@
+"""Canonical venue names.
+
+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.
+"""
+
+import re
+from dataclasses import dataclass
+from importlib import resources
+
+from .normalize import fold_ascii
+
+CATEGORY_HEADER = re.compile(r"%{2,}\s*(Journals|Conferences|Workshops)", re.I)
+STRING_DEF = re.compile(r'@string\{(\w+)\s*=\s*"([^"]+)"\}', re.I)
+
+# Entries whose section in strings.bib does not reflect how they are cited.
+CATEGORY_OVERRIDES = {
+    "RSS": "conference",  # listed among journals
+    "TMLR": "journal",  # listed among conferences
+    "SIGGRAPH": "journal",  # cited as ACM TOG articles
+    "SIGGRAPHAsia": "journal",
+}
+
+# Tokens dropped on BOTH sides before comparing venue names.
+DROP_TOKENS = frozenset(
+    "ieee cvf acm rsj the annual proceedings proc of on in".split()
+)
+
+# Hand-written aliases (normalized form -> macro) for spellings the automatic
+# alias generation cannot derive, e.g. DBLP's abbreviated journal names.
+EXTRA_ALIASES = {
+    "neural information processing systems": "NeurIPS",
+    "nips": "NIPS",
+    "trans pattern anal mach intell": "TPAMI",
+    "pattern analysis and machine intelligence": "TPAMI",
+    "j mach learn res": "JMLR",
+    "int j comput vis": "IJCV",
+    "trans mach learn res": "TMLR",
+    "transactions machine learning research": "TMLR",
+    "robotics autom lett": "RAL",
+    "robotics and automation letters": "RAL",
+    "computer vision and pattern recognition": "CVPR",
+    "winter applications computer vision": "WACV",
+    "aaai artificial intelligence": "AAAI",
+    "national aaai": "AAAI",
+    "aaai": "AAAI",
+    "acl": "ACL",
+    "emnlp": "EMNLP",
+    "naacl": "NAACL",
+    "naacl hlt": "NAACL",
+    "north american chapter association for computational linguistics": "NAACL",
+    "empirical methods natural language processing": "EMNLP",
+    "association for computational linguistics": "ACL",
+    "robotics science and systems": "RSS",
+    "3dv": "TDV",
+    "colt": "COLT92",
+    "computational learning theory": "COLT92",
+    "knowledge discovery and data mining": "KDD",
+    "int j robotics res": "IJRR",
+    "j field robotics": "IJRR",
+}
+
+
+@dataclass(frozen=True)
+class Venue:
+    macro: str
+    name: str  # canonical full name (LaTeX escapes removed at parse time? kept)
+    category: str  # "journal" | "conference" | "workshop"
+
+    @property
+    def is_journal(self) -> bool:
+        return self.category == "journal"
+
+    @property
+    def bib_field(self) -> str:
+        return "journal" if self.is_journal else "booktitle"
+
+    @property
+    def entry_type(self) -> str:
+        return "article" if self.is_journal else "inproceedings"
+
+
+def _norm(s: str) -> str:
+    """Normalize a venue string for comparison."""
+    s = fold_ascii(s).lower()
+    s = re.sub(r"\\(.)", r"\1", s)  # \& -> &
+    s = s.replace("&", " and ")
+    s = re.sub(r"\(.*?\)", " ", s)  # drop parentheticals (acronyms handled separately)
+    tokens = re.split(r"[^a-z0-9]+", s)
+    out = []
+    for t in tokens:
+        if not t or t in DROP_TOKENS:
+            continue
+        if t.isdigit() or re.fullmatch(r"\d+(st|nd|rd|th)", t):
+            continue
+        out.append(t)
+    return " ".join(out)
+
+
+def _acronyms(s: str) -> list[str]:
+    """Candidate acronyms in a raw venue string: parenthesized chunks and
+    standalone ALL-CAPS tokens, mini-hashed."""
+    cands = re.findall(r"\(([^()]+)\)", s)
+    cands += [t for t in re.split(r"[\s,.:]+", s) if len(t) >= 2 and t.isupper()]
+    out = []
+    for c in cands:
+        c = re.sub(r"[^a-z0-9]", "", fold_ascii(c).lower())
+        if c and c not in out:
+            out.append(c)
+    return out
+
+
+class VenueTable:
+    def __init__(self, text: str):
+        self.venues: dict[str, Venue] = {}
+        self._exact: dict[str, str] = {}  # normalized string -> macro
+        self._acr: dict[str, str] = {}  # minihashed acronym -> macro
+        self._containment: list[tuple[str, str]] = []  # (normalized full, macro)
+        self._parse(text)
+        self._build_aliases()
+
+    def _parse(self, text: str):
+        category = "journal"
+        for line in text.splitlines():
+            m = CATEGORY_HEADER.search(line)
+            if m:
+                category = m.group(1).lower().rstrip("s")  # journal/conference/workshop
+                continue
+            m = STRING_DEF.search(line)
+            if not m:
+                continue
+            macro, name = m.group(1), m.group(2)
+            cat = CATEGORY_OVERRIDES.get(macro, category)
+            self.venues[macro] = Venue(macro=macro, name=name, category=cat)
+
+    def _build_aliases(self):
+        for macro, v in self.venues.items():
+            mini = re.sub(r"[^a-z0-9]", "", macro.lower())
+            self._acr.setdefault(mini, macro)
+            for acr in _acronyms(v.name):
+                self._acr.setdefault(acr, macro)
+                # Workshop variants: "ICCV Workshops" style aliases.
+                if v.category == "workshop" and acr.endswith("w"):
+                    self._exact.setdefault(f"{acr[:-1]} workshops", macro)
+            n = _norm(v.name)
+            if n:
+                self._exact.setdefault(n, macro)
+                if len(n.split()) >= 3:
+                    self._containment.append((n, macro))
+        for alias, macro in EXTRA_ALIASES.items():
+            self._exact[alias] = macro
+        # Longest names first so e.g. ICCVW ("... computer vision workshops")
+        # wins over ICCV on containment.
+        self._containment.sort(key=lambda p: -len(p[0]))
+
+    # ------------------------------------------------------------------
+    def canonicalize(self, venue: str, year: int | str | None = None) -> Venue | None:
+        """Map an arbitrary venue string to a canonical Venue, or None."""
+        if not venue or not venue.strip():
+            return None
+        raw = venue.strip()
+        n = _norm(raw)
+        lowered = re.sub(r"[^a-z0-9]", "", fold_ascii(raw).lower())
+        is_workshoppy = "workshop" in n
+
+        macro = None
+        # 1. exact normalized-name / alias match
+        if n in self._exact:
+            macro = self._exact[n]
+        # 2. the whole string is an acronym (e.g. DBLP venue "CVPR")
+        if macro is None and lowered in self._acr:
+            macro = self._acr[lowered]
+        # 3. embedded acronyms — prefer workshop variants when applicable
+        if macro is None:
+            for acr in _acronyms(raw):
+                if is_workshoppy and acr + "w" in self._acr:
+                    macro = self._acr[acr + "w"]
+                    break
+                if acr in self._acr:
+                    macro = self._acr[acr]
+                    break
+        # 4. containment of the canonical full name in the venue string
+        if macro is None:
+            for full, m in self._containment:
+                if full in n:
+                    macro = m
+                    break
+        if macro is None:
+            return None
+        macro = self._apply_year_rules(macro, year)
+        return self.venues[macro]
+
+    @staticmethod
+    def _year_int(year) -> int | None:
+        try:
+            return int(str(year)[:4])
+        except (TypeError, ValueError):
+            return None
+
+    def _apply_year_rules(self, macro: str, year) -> str:
+        y = self._year_int(year)
+        if macro in ("NIPS", "NeurIPS"):
+            if y is None:
+                return "NeurIPS"
+            return "NeurIPS" if y >= 2018 else "NIPS"
+        if macro in ("WACV", "WACV_until_2016"):
+            if y is not None and y <= 2016:
+                return "WACV_until_2016"
+            return "WACV"
+        return macro
+
+
+_table: VenueTable | None = None
+
+
+def _strings_text() -> str:
+    """The @string table, overridable so other people can use their own:
+    $BIBCITE_STRINGS, then ~/.config/bibcite/strings.bib, then the vendored
+    default."""
+    import os
+    from pathlib import Path
+
+    env = os.environ.get("BIBCITE_STRINGS")
+    if env:
+        return Path(env).read_text()
+    user = Path.home() / ".config" / "bibcite" / "strings.bib"
+    if user.exists():
+        return user.read_text()
+    return (resources.files("bibcite") / "data" / "strings.bib").read_text()
+
+
+def get_table() -> VenueTable:
+    global _table
+    if _table is None:
+        _table = VenueTable(_strings_text())
+    return _table
+
+
+def canonicalize(venue: str, year=None) -> Venue | None:
+    return get_table().canonicalize(venue, year)

bibcite_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: bibcite-cli
+Version: 0.1.0
+Summary: Resolve papers (arXiv id / DOI / title) to canonical, normalized BibTeX for agents and humans
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arxiv,bibliography,bibtex,citations,dblp
+Requires-Python: >=3.10
+Requires-Dist: bibtexparser<2,>=1.4
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# bibcite
+
+Resolve papers (arXiv id / DOI / title) to canonical, normalized BibTeX, and manage `.bib` files so agents never hand-edit them.
+
+The publication-matching cascade is ported from [PaperMemory](https://github.com/vict0rsch/PaperMemory)'s bibMatcher:
+DBLP → Semantic Scholar → Google Scholar → CrossRef → Unpaywall.
+A match must have an identical normalized title, a plausible year, and a non-preprint venue.
+
+Venue names are canonicalized against the `@string` table vendored in `src/bibcite/data/strings.bib` (journals / conferences / workshops), including year-aware rules (NIPS before 2018 vs NeurIPS, WACV before 2017).
+
+Entry types are strict: conference/workshop papers become `@inproceedings` + `booktitle`, journal papers `@article` + `journal`, and unpublished arXiv preprints `@misc` + `howpublished = {arXiv preprint arXiv:ID}`.
+Types coming from authoritative source BibTeX (DBLP) are preserved.
+
+After every write, the file is formatted with [bibtex-tidy](https://github.com/FlamingTempura/bibtex-tidy) using the canonical flags in `bibfile.TIDY_ARGS` (requires `bibtex-tidy` on PATH or `npx`).
+
+## Install
+
+```bash
+# from a local checkout (development)
+uv tool install --editable .
+
+# from git, no checkout needed
+uv tool install git+https://github.com/<you>/bibcite
+
+# once published to PyPI (package name bibcite-cli, command name bibcite)
+uv tool install bibcite-cli   # or: uvx --from bibcite-cli bibcite ...
+
+# plus, once (required for the tidy step):
+npm install -g bibtex-tidy
+```
+
+To use your own venue table instead of the vendored one, set `BIBCITE_STRINGS=/path/to/strings.bib` or place it at `~/.config/bibcite/strings.bib`.
+
+## Usage
+
+```bash
+# Preview the BibTeX for a paper (nothing written)
+bibcite get 1706.03762
+bibcite get "Attention is all you need"
+bibcite get 10.1109/CVPR52688.2022.01167
+
+# Resolve and write into a .bib file, dedupe, then bibtex-tidy; prints the final key
+bibcite add refs.bib 2103.14030 --json
+
+# Add a raw BibTeX entry you already have (venue still canonicalized, file still tidied)
+bibcite add refs.bib --bibtex "$(pbpaste)"
+
+# Upgrade every arXiv entry in a file to its published version (bibMatcher, CLI-style)
+bibcite upgrade refs.bib --dry-run
+
+# Just format, or just lint
+bibcite tidy refs.bib
+bibcite check refs.bib
+```
+
+`--json` prints a machine-readable result on stdout (`action`, `key`, `venue`, `source`, ...); all diagnostics go to stderr.
+`add` is idempotent: an existing entry returns `action: exists` with its key, and an existing arXiv entry matched to a published version is upgraded in place, keeping its citation key.
+
+## For agents
+
+Never edit `.bib` files by hand.
+Call `bibcite add <file> <query> --json` and use the returned `key` in `\cite{...}`.

bibcite_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+bibcite/__init__.py,sha256=LlyEv0C1TqMB-9wU1T35LcRK2J090totd8_QA1lS5Uk,103
+bibcite/bibfile.py,sha256=2MYJ4ptanwKsmwywV5WiVe1y70vQ6_PQuCW-U74J3sI,6183
+bibcite/cli.py,sha256=tt9G67JBW5Dimy-MBN6A0OyzL0-wHSCZzgRTPI8e2ls,9811
+bibcite/normalize.py,sha256=FOPh678mb87hULJa4W8nZa259M0a8HnniS-icPVnrk8,3303
+bibcite/resolve.py,sha256=nxQMHx3M3X3D9amQHokfWSOX-Dey0GRG45wyBh3zfH4,10867
+bibcite/sources.py,sha256=MqqOagO3VcVcZZftAKRXwhFEKeOIOZb2p57u77Ng1oc,21108
+bibcite/venues.py,sha256=vINYhIvCHv2UwyMBXMvuncmX6bSb-Wp91dqp7qLmx-0,8553
+bibcite/data/strings.bib,sha256=OokHlBtiExDmBRo3NTYZGgVtKYb4TLQ1-U2VDNZcEP8,12381
+bibcite_cli-0.1.0.dist-info/METADATA,sha256=RzF9Ycn4YWBtNiFt5GMv7zOSZxgaOGhDlVhZ9fpgIFg,3129
+bibcite_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bibcite_cli-0.1.0.dist-info/entry_points.txt,sha256=EKrDiAWGIjWyS_XTRAC9A0_FQL73xZjXjso6Fjf3w00,45
+bibcite_cli-0.1.0.dist-info/licenses/LICENSE,sha256=TKJKgSgrKkEWgJwigqLIGNf0tUaT-2NsM25jMwdgszU,1065
+bibcite_cli-0.1.0.dist-info/RECORD,,

bibcite_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

bibcite_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bibcite = bibcite.cli:main

bibcite_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonardo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.