pyDiffTools 0.1.33__tar.gz → 0.1.35__tar.gz

{pydifftools-0.1.33/pyDiffTools.egg-info → pydifftools-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.33
+Version: 0.1.35
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -96,6 +96,47 @@ included are (listed in order of fun/utility):
   (currently tested on windows with *version 3.5* of the former,
   *not the latest installer*,
   since crossref isn't built with the most recent version).
+
+  When Pandoc reports missing citations, ``cpb`` retrieves their BibTeX
+  entries from the running local Zotero application, updates the active
+  bibliography, and rebuilds once. Install and enable
+  `Better BibTeX <https://retorque.re/zotero-better-bibtex/installation/>`_
+  in Zotero. No API key or Python dependency is needed. The integration uses
+  Better BibTeX's documented
+  `local JSON-RPC API <https://retorque.re/zotero-better-bibtex/exporting/json-rpc/>`_
+  at ``127.0.0.1:23119`` and searches the default personal library.
+  Zotero supports Windows, macOS, and Linux; this integration uses portable
+  Python file operations and Qt dialogs. Its automated runtime checks have
+  been performed on Linux, not on Windows.
+
+  Declare a single local ``.bib`` file with ``bibliography: references.bib``
+  in the Markdown YAML header; relative paths are resolved beside the
+  Markdown file. Without that declaration, ``cpb`` uses a single adjacent
+  ``.bib`` file. Multiple or unsupported bibliographies are rendered normally
+  but are not automatically edited. Missing keys, unavailable Zotero, and
+  failed updates produce warnings; rendering continues. If Zotero or Better
+  BibTeX is unavailable at startup, an informational Qt window explains the
+  feature without blocking the preview.
+
+  Before importing a possible duplicate, a Qt dialog offers keeping the
+  existing entry, keeping the Zotero entry, or merging selected fields.
+  Matching uses DOI, book ISBN/edition, or a similar title with the same
+  first author and year. Conflicting DOIs are not treated as duplicates.
+  This follows the identifier and field comparison approach used by
+  `JabRef <https://docs.jabref.org/finding-sorting-and-cleaning-entries/mergeentries>`_.
+  The merge defaults to existing values and the existing key, filling absent
+  fields from Zotero. You can also keep both entries or skip an import.
+  After resolving a duplicate, ``@UNCHOSEN`` becomes ``@CHOSEN`` in the active
+  Markdown document. Code, links, ordinary text, and other documents are not
+  rewritten. Untouched bibliography entries retain their original text.
+  Edits made while a lookup or dialog is in progress abort the update.
+
+  Tests use recorded Zotero responses and real Pandoc. For the optional local
+  smoke tests, run ``PYDIFFTOOLS_ZOTERO_LIVE=1 python -m pytest -q
+  tests/test_zotero.py``. This additionally checks the live Hoult export and
+  builds a temporary copy of ``~/notebook/papers/eigenmode``, verifying that
+  the original files are unchanged. The ordinary suite requires neither
+  Zotero nor this notebook directory.
 - `pydifft wgrph <graph.yaml>` watches a YAML flowchart description,
   rebuilds the DOT/SVG output using GraphViz, and keeps a browser window
   refreshed as you edit the file.  This wraps the former

{pydifftools-0.1.33 → pydifftools-0.1.35}/README.rst

@@ -41,6 +41,47 @@ included are (listed in order of fun/utility):
   (currently tested on windows with *version 3.5* of the former,
   *not the latest installer*,
   since crossref isn't built with the most recent version).
+
+  When Pandoc reports missing citations, ``cpb`` retrieves their BibTeX
+  entries from the running local Zotero application, updates the active
+  bibliography, and rebuilds once. Install and enable
+  `Better BibTeX <https://retorque.re/zotero-better-bibtex/installation/>`_
+  in Zotero. No API key or Python dependency is needed. The integration uses
+  Better BibTeX's documented
+  `local JSON-RPC API <https://retorque.re/zotero-better-bibtex/exporting/json-rpc/>`_
+  at ``127.0.0.1:23119`` and searches the default personal library.
+  Zotero supports Windows, macOS, and Linux; this integration uses portable
+  Python file operations and Qt dialogs. Its automated runtime checks have
+  been performed on Linux, not on Windows.
+
+  Declare a single local ``.bib`` file with ``bibliography: references.bib``
+  in the Markdown YAML header; relative paths are resolved beside the
+  Markdown file. Without that declaration, ``cpb`` uses a single adjacent
+  ``.bib`` file. Multiple or unsupported bibliographies are rendered normally
+  but are not automatically edited. Missing keys, unavailable Zotero, and
+  failed updates produce warnings; rendering continues. If Zotero or Better
+  BibTeX is unavailable at startup, an informational Qt window explains the
+  feature without blocking the preview.
+
+  Before importing a possible duplicate, a Qt dialog offers keeping the
+  existing entry, keeping the Zotero entry, or merging selected fields.
+  Matching uses DOI, book ISBN/edition, or a similar title with the same
+  first author and year. Conflicting DOIs are not treated as duplicates.
+  This follows the identifier and field comparison approach used by
+  `JabRef <https://docs.jabref.org/finding-sorting-and-cleaning-entries/mergeentries>`_.
+  The merge defaults to existing values and the existing key, filling absent
+  fields from Zotero. You can also keep both entries or skip an import.
+  After resolving a duplicate, ``@UNCHOSEN`` becomes ``@CHOSEN`` in the active
+  Markdown document. Code, links, ordinary text, and other documents are not
+  rewritten. Untouched bibliography entries retain their original text.
+  Edits made while a lookup or dialog is in progress abort the update.
+
+  Tests use recorded Zotero responses and real Pandoc. For the optional local
+  smoke tests, run ``PYDIFFTOOLS_ZOTERO_LIVE=1 python -m pytest -q
+  tests/test_zotero.py``. This additionally checks the live Hoult export and
+  builds a temporary copy of ``~/notebook/papers/eigenmode``, verifying that
+  the original files are unchanged. The ordinary suite requires neither
+  Zotero nor this notebook directory.
 - `pydifft wgrph <graph.yaml>` watches a YAML flowchart description,
   rebuilds the DOT/SVG output using GraphViz, and keeps a browser window
   refreshed as you edit the file.  This wraps the former

{pydifftools-0.1.33 → pydifftools-0.1.35/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.33
+Version: 0.1.35
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -96,6 +96,47 @@ included are (listed in order of fun/utility):
   (currently tested on windows with *version 3.5* of the former,
   *not the latest installer*,
   since crossref isn't built with the most recent version).
+
+  When Pandoc reports missing citations, ``cpb`` retrieves their BibTeX
+  entries from the running local Zotero application, updates the active
+  bibliography, and rebuilds once. Install and enable
+  `Better BibTeX <https://retorque.re/zotero-better-bibtex/installation/>`_
+  in Zotero. No API key or Python dependency is needed. The integration uses
+  Better BibTeX's documented
+  `local JSON-RPC API <https://retorque.re/zotero-better-bibtex/exporting/json-rpc/>`_
+  at ``127.0.0.1:23119`` and searches the default personal library.
+  Zotero supports Windows, macOS, and Linux; this integration uses portable
+  Python file operations and Qt dialogs. Its automated runtime checks have
+  been performed on Linux, not on Windows.
+
+  Declare a single local ``.bib`` file with ``bibliography: references.bib``
+  in the Markdown YAML header; relative paths are resolved beside the
+  Markdown file. Without that declaration, ``cpb`` uses a single adjacent
+  ``.bib`` file. Multiple or unsupported bibliographies are rendered normally
+  but are not automatically edited. Missing keys, unavailable Zotero, and
+  failed updates produce warnings; rendering continues. If Zotero or Better
+  BibTeX is unavailable at startup, an informational Qt window explains the
+  feature without blocking the preview.
+
+  Before importing a possible duplicate, a Qt dialog offers keeping the
+  existing entry, keeping the Zotero entry, or merging selected fields.
+  Matching uses DOI, book ISBN/edition, or a similar title with the same
+  first author and year. Conflicting DOIs are not treated as duplicates.
+  This follows the identifier and field comparison approach used by
+  `JabRef <https://docs.jabref.org/finding-sorting-and-cleaning-entries/mergeentries>`_.
+  The merge defaults to existing values and the existing key, filling absent
+  fields from Zotero. You can also keep both entries or skip an import.
+  After resolving a duplicate, ``@UNCHOSEN`` becomes ``@CHOSEN`` in the active
+  Markdown document. Code, links, ordinary text, and other documents are not
+  rewritten. Untouched bibliography entries retain their original text.
+  Edits made while a lookup or dialog is in progress abort the update.
+
+  Tests use recorded Zotero responses and real Pandoc. For the optional local
+  smoke tests, run ``PYDIFFTOOLS_ZOTERO_LIVE=1 python -m pytest -q
+  tests/test_zotero.py``. This additionally checks the live Hoult export and
+  builds a temporary copy of ``~/notebook/papers/eigenmode``, verifying that
+  the original files are unchanged. The ordinary suite requires neither
+  Zotero nor this notebook directory.
 - `pydifft wgrph <graph.yaml>` watches a YAML flowchart description,
   rebuilds the DOT/SVG output using GraphViz, and keeps a browser window
   refreshed as you edit the file.  This wraps the former

{pydifftools-0.1.33 → pydifftools-0.1.35}/pyDiffTools.egg-info/SOURCES.txt

@@ -45,8 +45,10 @@ pyDiffTools.egg-info/entry_points.txt
 pyDiffTools.egg-info/requires.txt
 pyDiffTools.egg-info/top_level.txt
 pydifftools/__init__.py
+pydifftools/bibliography.py
 pydifftools/browser_lifecycle.py
 pydifftools/check_numbers.py
+pydifftools/citation_dialog.py
 pydifftools/command_line.py
 pydifftools/command_registry.py
 pydifftools/comment_functions.py
@@ -79,6 +81,7 @@ pydifftools/unseparate_comments.py
 pydifftools/update_check.py
 pydifftools/wrap_sentences.py
 pydifftools/xml2xlsx.vbs
+pydifftools/zotero.py
 pydifftools/flowchart/__init__.py
 pydifftools/flowchart/comparison.py
 pydifftools/flowchart/dot_to_yaml.py
@@ -90,6 +93,7 @@ pydifftools/notebook/__init__.py
 pydifftools/notebook/display.py
 pydifftools/notebook/fast_build.py
 pydifftools/notebook/tex_to_qmd.py
+tests/test_bibliography.py
 tests/test_browser_lifecycle.py
 tests/test_check_single_use.py
 tests/test_command_line_help.py
@@ -102,4 +106,5 @@ tests/test_rrng.py
 tests/test_tex_to_qmd.py
 tests/test_update_check.py
 tests/test_wrap_check.py
-tests/test_wrapping.py
+tests/test_wrapping.py
+tests/test_zotero.py

pydifftools-0.1.35/pydifftools/bibliography.py

@@ -0,0 +1,305 @@
+"""Lossless BibTeX edits and citation-aware Markdown key changes.
+
+Pandoc remains the semantic parser. The small scanner here only locates raw
+entry/field boundaries, preserving macros, custom fields and untouched text.
+"""
+
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+import html
+import json
+import os
+from pathlib import Path
+import re
+import stat
+import subprocess
+import sys
+import tempfile
+import unicodedata
+
+
+def scan_bibtex(text, start, stops):
+    """Locate an unquoted delimiter outside balanced braces."""
+    depth = 0
+    quoted = False
+    position = start
+    while position < len(text):
+        char = text[position]
+        if char == "\\":
+            position += 2
+            continue
+        if char == "%" and depth == 0 and not quoted:
+            newline = text.find("\n", position)
+            position = len(text) if newline < 0 else newline + 1
+            continue
+        if depth == 0 and not quoted and char in stops:
+            return position
+        if char == '"' and depth == 0:
+            quoted = not quoted
+        elif char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth < 0:
+                raise ValueError("unbalanced BibTeX braces")
+        position += 1
+    if depth or quoted:
+        raise ValueError("unterminated BibTeX value")
+    return position
+
+
+@dataclass
+class BibEntry:
+    start: int
+    end: int
+    kind: str
+    key: str
+    fields: dict
+
+    def render(self, key=None, fields=None):
+        selected = self.fields if fields is None else fields
+        body = ",\n".join(
+            f"  {name} = {value}" for name, value in selected.items()
+        )
+        return f"@{self.kind}{{{key or self.key},\n{body}\n}}"
+
+
+def bib_entries(text):
+    """Index entry spans and raw fields without reserializing them."""
+    entries = {}
+    position = 0
+    while position < len(text):
+        position = scan_bibtex(text, position, "@")
+        if position == len(text):
+            break
+        header = re.match(r"@([\w-]+)\s*([{(])", text[position:])
+        if not header:
+            position += 1
+            continue
+        start = position
+        kind = header[1].lower()
+        position += header.end()
+        closing = "}" if header[2] == "{" else ")"
+        end = scan_bibtex(text, position, closing)
+        if end == len(text):
+            raise ValueError("unterminated BibTeX entry")
+        body = text[position:end]
+        position = end + 1
+        if kind in {"comment", "preamble", "string"}:
+            continue
+        key_end = scan_bibtex(body, 0, ",")
+        key = body[:key_end].strip()
+        fields = {}
+        offset = key_end + 1
+        while offset < len(body):
+            whitespace = re.match(r"(?:\s|%[^\n]*(?:\n|$))*", body[offset:])
+            offset += whitespace.end()
+            if offset == len(body):
+                break
+            field = re.match(r"([\w-]+)\s*=\s*", body[offset:])
+            if not field:
+                raise ValueError(f"cannot safely edit BibTeX fields in {key}")
+            offset += field.end()
+            boundary = scan_bibtex(body, offset, ",")
+            name = field[1].lower()
+            if name in fields:
+                raise ValueError(f"duplicate BibTeX field {name} in {key}")
+            fields[name] = body[offset:boundary].strip()
+            offset = boundary + 1
+        if key in entries:
+            raise ValueError(f"duplicate BibTeX key {key}")
+        entries[key] = BibEntry(start, end + 1, kind, key, fields)
+    return entries
+
+
+def normalized_text(value):
+    text = html.unescape(re.sub(r"<[^>]+>", "", str(value)))
+    text = unicodedata.normalize("NFKD", text).casefold()
+    return "".join(char for char in text if char.isalnum())
+
+
+def duplicate_reason(existing, incoming):
+    """Identify likely duplicates for human review using Pandoc CSL records.
+
+    Inspired by JabRef's identifier-first, bibliographic-field comparison:
+    https://github.com/JabRef/jabref/blob/main/jablib/src/main/java/org/jabref/
+    logic/database/DuplicateCheck.java. No Java code is copied.
+    """
+    identifiers = []
+    for record in (existing, incoming):
+        doi = str(record.get("DOI", "")).strip().casefold()
+        identifiers.append(
+            re.sub(r"^(?:https?://(?:dx\.)?doi.org/|doi:\s*)", "", doi)
+        )
+    if all(identifiers):
+        return "Same DOI" if identifiers[0] == identifiers[1] else None
+    if existing.get("type") != incoming.get("type"):
+        return None
+    for field in ("edition", "chapter-number"):
+        if existing.get(field) and incoming.get(field):
+            if normalized_text(existing[field]) != normalized_text(
+                incoming[field]
+            ):
+                return None
+    if existing.get("type") == "chapter":
+        if normalized_text(existing.get("page")) != normalized_text(
+            incoming.get("page")
+        ):
+            return None
+    if existing.get("type") == "book":
+        isbn = normalized_text(existing.get("ISBN", ""))
+        if isbn and isbn == normalized_text(incoming.get("ISBN", "")):
+            return "Same ISBN and edition"
+    titles = [
+        normalized_text(record.get("title", ""))
+        for record in (existing, incoming)
+    ]
+    authors = [
+        record.get("author", record.get("editor", []))
+        for record in (existing, incoming)
+    ]
+    years = [
+        record.get("issued", {}).get("date-parts", [[]])[0][:1]
+        for record in (existing, incoming)
+    ]
+    if not all(titles) or not all(authors) or not all(years):
+        return None
+    surnames = [
+        normalized_text(names[0].get("family", names[0].get("literal", "")))
+        for names in authors
+    ]
+    similar_title = titles[0] == titles[1] or (
+        min(map(len, titles)) >= 20
+        and SequenceMatcher(None, *titles).ratio() >= 0.92
+    )
+    if (
+        similar_title
+        and surnames[0]
+        and surnames[0] == surnames[1]
+        and years[0] == years[1]
+    ):
+        return "Similar title, same first author and year"
+    return None
+
+
+def markdown_ast(text, renames=None):
+    """Parse Markdown, optionally normalizing citation IDs for comparison."""
+    completed = subprocess.run(
+        ["pandoc", "--from=markdown-auto_identifiers", "--to=json"],
+        input=text.encode("utf-8"),
+        capture_output=True,
+    )
+    if completed.returncode:
+        raise ValueError("cannot parse Markdown to update citation keys")
+    tree = json.loads(completed.stdout)
+    if renames is not None:
+        pending = [tree]
+        while pending:
+            node = pending.pop()
+            if isinstance(node, dict):
+                if node.get("t") == "Cite":
+                    # Pandoc stores both parsed citations and their source
+                    # spelling; spelling changes when a key is renamed.
+                    node["c"][1] = []
+                    for citation in node["c"][0]:
+                        old = citation["citationId"]
+                        citation["citationId"] = renames.get(old, old)
+                pending.extend(node.values())
+            elif isinstance(node, list):
+                pending.extend(node)
+    return tree
+
+
+def rewrite_citations(markdown, renames):
+    """Replace citation tokens, accepting edits only when Pandoc confirms them.
+
+    AST comparison protects code, links, email addresses, comments, ordinary
+    text and keys with a shared prefix, while retaining original formatting.
+    """
+    text = markdown.decode("utf-8")
+    if not renames:
+        return markdown
+    expected = markdown_ast(text, renames)
+    keys = sorted(renames, key=len, reverse=True)
+    pattern = re.compile(
+        r"@(?:\{("
+        + "|".join(map(re.escape, keys))
+        + r")\}|("
+        + "|".join(map(re.escape, keys))
+        + r"))"
+    )
+    for match in reversed(list(pattern.finditer(text))):
+        old = match[1] or match[2]
+        replacement = (
+            "@{" + renames[old] + "}" if match[1] else "@" + renames[old]
+        )
+        candidate = text[: match.start()] + replacement + text[match.end() :]
+        if markdown_ast(candidate, renames) == expected:
+            text = candidate
+    if markdown_ast(text, {}) != expected:
+        raise ValueError("could not safely update all Markdown citation keys")
+    return text.encode("utf-8")
+
+
+def replace_bibliography_files(changes):
+    """Stage validated replacements and roll back if a later replacement fails.
+
+    Changes map paths to (original bytes, replacement bytes). Files are closed
+    before replacement for Windows. A crash across two replacements cannot be
+    atomic; ordinary write failures are rolled back without overwriting edits.
+    """
+    staged = {}
+    backups = {}
+    committed = []
+    temporaries = []
+    try:
+        for path, (original, replacement) in changes.items():
+            path = Path(path)
+            if replacement == original:
+                continue
+            mode = stat.S_IMODE(path.stat().st_mode)
+            if not mode & 0o222 or not os.access(path, os.W_OK):
+                raise PermissionError(f"file is not writable: {path}")
+            for content, targets in [
+                (original, backups),
+                (replacement, staged),
+            ]:
+                with tempfile.NamedTemporaryFile(
+                    dir=path.parent, prefix=f".{path.name}.", delete=False
+                ) as output:
+                    temporary = Path(output.name)
+                    temporaries.append(temporary)
+                    output.write(content)
+                    output.flush()
+                    os.fsync(output.fileno())
+                os.chmod(temporary, mode)
+                targets[path] = temporary
+        for path, (original, _) in changes.items():
+            if Path(path).read_bytes() != original:
+                raise ValueError(f"file changed during Zotero lookup: {path}")
+        for path in staged:
+            if path.read_bytes() != changes[path][0]:
+                raise ValueError(f"file changed during Zotero lookup: {path}")
+            os.replace(staged[path], path)
+            committed.append(path)
+    except (OSError, ValueError):
+        for path in reversed(committed):
+            if path.read_bytes() == changes[path][1]:
+                try:
+                    os.replace(backups[path], path)
+                except OSError as exc:
+                    # Keep a recovery copy if even rollback is prevented.
+                    temporaries.remove(backups[path])
+                    raise OSError(
+                        f"could not restore {path}; original saved at "
+                        f"{backups[path]}"
+                    ) from exc
+        raise
+    finally:
+        for temporary in temporaries:
+            try:
+                temporary.unlink(missing_ok=True)
+            except OSError as exc:
+                print(
+                    f"cpb: cannot remove {temporary}: {exc}", file=sys.stderr
+                )

pydifftools-0.1.35/pydifftools/citation_dialog.py

@@ -0,0 +1,124 @@
+"""Qt review of a possible duplicate citation, run in a separate process."""
+
+import json
+import sys
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QApplication,
+    QComboBox,
+    QDialog,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+)
+
+
+class DuplicateDialog(QDialog):
+    """Choose an entry or merge fields; default to existing values and key."""
+
+    def __init__(self, matches, incoming, source):
+        super().__init__()
+        self.matches = matches
+        self.incoming = incoming
+        self.decision = None
+        self.setWindowTitle("pydifft cpb — Possible duplicate citation")
+        self.resize(1000, 650)
+        layout = QVBoxLayout(self)
+        explanation = QLabel(
+            f"Review the imported citation for {source}.\n"
+            "Keeping or merging a duplicate also replaces @UNCHOSEN with "
+            "@CHOSEN in this Markdown file. Other documents are not edited.\n"
+            "For a merge, choose each field below, including the citation key."
+        )
+        explanation.setWordWrap(True)
+        layout.addWidget(explanation)
+        self.match_selector = QComboBox()
+        for match in matches:
+            self.match_selector.addItem(f"{match['key']} — {match['reason']}")
+        layout.addWidget(self.match_selector)
+        self.table = QTableWidget()
+        self.table.setColumnCount(4)
+        self.table.setHorizontalHeaderLabels(
+            ["Field", "Existing bibliography", "Zotero", "Merge uses"]
+        )
+        self.table.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeMode.Stretch
+        )
+        layout.addWidget(self.table)
+        buttons = QHBoxLayout()
+        self.buttons = {}
+        for label, action in [
+            ("Keep existing", "existing"),
+            ("Keep Zotero", "incoming"),
+            ("Merge selected fields", "merge"),
+            ("Not a duplicate: keep both", "both"),
+            ("Skip this import", "skip"),
+        ]:
+            button = QPushButton(label)
+            button.setAutoDefault(False)
+            button.clicked.connect(
+                lambda _checked=False, choice=action: self.choose(choice)
+            )
+            self.buttons[action] = button
+            buttons.addWidget(button)
+        layout.addLayout(buttons)
+        self.match_selector.currentIndexChanged.connect(self.populate)
+        self.populate()
+
+    def populate(self):
+        existing = self.matches[self.match_selector.currentIndex()]
+        self.left = {
+            "citation key": existing["key"],
+            "entry type": existing["kind"],
+            **existing["fields"],
+        }
+        self.right = {
+            "citation key": self.incoming["key"],
+            "entry type": self.incoming["kind"],
+            **self.incoming["fields"],
+        }
+        self.names = list(dict.fromkeys([*self.left, *self.right]))
+        self.table.setRowCount(len(self.names))
+        self.selectors = {}
+        for row, name in enumerate(self.names):
+            for column, value in enumerate(
+                [name, self.left.get(name, ""), self.right.get(name, "")]
+            ):
+                cell = QTableWidgetItem(value)
+                cell.setFlags(cell.flags() & ~Qt.ItemFlag.ItemIsEditable)
+                self.table.setItem(row, column, cell)
+            selector = QComboBox()
+            if name in self.left:
+                selector.addItem("Existing", self.left[name])
+            if name in self.right:
+                selector.addItem("Zotero", self.right[name])
+            self.table.setCellWidget(row, 3, selector)
+            self.selectors[name] = selector
+        self.table.resizeRowsToContents()
+
+    def choose(self, action):
+        existing = self.matches[self.match_selector.currentIndex()]
+        self.decision = {"action": action, "existing_key": existing["key"]}
+        if action == "merge":
+            values = {
+                name: selector.currentData()
+                for name, selector in self.selectors.items()
+            }
+            self.decision.update(
+                key=values.pop("citation key"),
+                kind=values.pop("entry type"),
+                fields=values,
+            )
+        self.accept()
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv[:1])
+    dialog = DuplicateDialog(**json.load(sys.stdin))
+    dialog.exec()
+    print(json.dumps(dialog.decision))