calkit-python 0.41.8__tar.gz → 0.41.9__tar.gz

{calkit_python-0.41.8 → calkit_python-0.41.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.8
+Version: 0.41.9
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.41.8 → calkit_python-0.41.9}/calkit/cli/new.py

@@ -3143,7 +3143,7 @@ def new_release(
             )
             with open("LICENSE", "w") as f:
                 f.write(license_txt)
-                repo.git.add("LICENSE")
+            repo.git.add("LICENSE")
             license_ids = ["mit", "cc-by-4.0"]
         else:
             typer.echo(f"Detecting license(s) from {license_file}")
@@ -3394,38 +3394,23 @@ def new_release(
         doi_base_url = calkit.releases.SERVICES[to]["url"]
         doi_md = (
             f"[![DOI]({doi_base_url}/badge/DOI/{doi}.svg)]"
-            f"(https://handle.stage.datacite.org/{doi})"
+            f"(https://doi.org/{doi})"
         )
         if os.path.isfile("README.md"):
             with open("README.md") as f:
                 readme_txt = f.read()
         else:
-            readme_txt = f"# {title}\n"
-        existing_lines = readme_txt.split("\n")
-        new_lines = []
-        first_content_line_index = None
-        for n, line in enumerate(existing_lines):
-            if line.startswith(doi_md[:6]):
-                pass  # Skip DOI lines
-            else:
-                if (
-                    n != 0
-                    and line.strip()
-                    and first_content_line_index is None
-                ):
-                    first_content_line_index = len(new_lines)
-                new_lines.append(line)
-        # Ensure first 3 lines are title, blank, DOI lines
-        new_lines = (
-            [new_lines[0]]
-            + ["", doi_md, ""]
-            + new_lines[first_content_line_index:]
+            readme_txt = ""
+        readme_txt = calkit.releases.add_doi_badge_to_readme(
+            readme_txt, badge=doi_md, title=title
         )
-        readme_txt = "\n".join(new_lines)
         if not dry_run:
             with open("README.md", "w") as f:
                 f.write(readme_txt)
-                repo.git.add("README.md")
+            # Stage only after the file is closed; otherwise the buffered
+            # contents may not be flushed to disk yet and Git would stage an
+            # empty file
+            repo.git.add("README.md")
         else:
             typer.echo(f"Would have updated README.md to:\n{readme_txt}")
     # Create Git tag
@@ -3480,11 +3465,13 @@ def new_release(
         references = reference_collections[0]
     ref_path = references.get("path", "references.bib")
     try:
+        # Read the existing references as raw text so we can append the new
+        # entry without reformatting the user's existing entries
         if os.path.isfile(ref_path):
             with open(ref_path) as f:
-                reflib = bibtexparser.load(f)
+                existing_text = f.read()
         else:
-            reflib = bibtexparser.bibdatabase.BibDatabase()
+            existing_text = ""
         bibtex_doi = doi
         if bibtex_doi is None and dry_run:
             mock_suffix = "".join(
@@ -3504,31 +3491,38 @@ def new_release(
         if not new_entries:
             raise ValueError("Failed to parse generated BibTeX entry")
         new_entry = new_entries[0]
-        # Search through entries for one with the same DOI, and replace if
-        # there is a match
+        # Search through existing entries for any with the same DOI, and
+        # replace them (by citation key) if there is a match. Tolerate parse
+        # errors here (e.g., non-standard or temporarily-invalid BibTeX) by
+        # skipping replacement detection and still appending the new entry.
         new_doi = new_entry.get("doi")
-        matching_indices = []
+        replace_ids = []
         if new_doi:
-            matching_indices = [
-                n
-                for n, entry in enumerate(reflib.entries)
+            try:
+                existing_entries = bibtexparser.loads(existing_text).entries
+            except Exception as e:
+                warn(f"Could not parse existing references to dedupe: {e}")
+                existing_entries = []
+            replace_ids = [
+                entry["ID"]
+                for entry in existing_entries
                 if entry.get("doi") == new_doi
             ]
-        if matching_indices:
+        if replace_ids:
             typer.echo(
                 "Found matching DOI in existing references "
-                f"({len(matching_indices)} entr"
-                f"{'y' if len(matching_indices) == 1 else 'ies'}); "
+                f"({len(replace_ids)} entr"
+                f"{'y' if len(replace_ids) == 1 else 'ies'}); "
                 "replacing"
             )
-            for n in reversed(matching_indices):
-                _ = reflib.entries.pop(n)
-        reflib.entries.append(new_entry)
+        new_text = calkit.releases.add_bibtex_entry(
+            existing_text, invenio_bibtex, replace_ids=replace_ids
+        )
         if dry_run:
             typer.echo(f"Would write updated references to {ref_path}")
         else:
             with open(ref_path, "w") as f:
-                bibtexparser.dump(reflib, f)
+                f.write(new_text)
             repo.git.add(ref_path)
     except Exception as e:
         warn(f"Failed to add to references: {e}")

{calkit_python-0.41.8 → calkit_python-0.41.9}/calkit/releases.py

@@ -86,6 +86,109 @@ def create_bibtex(
     )
 
 
+def _find_bibtex_entry_span(
+    text: str, entry_id: str
+) -> tuple[int, int] | None:
+    """Locate the raw character span of a BibTeX entry by its citation key.
+
+    Returns ``(start, end)`` offsets into ``text`` where ``end`` is exclusive
+    (just past the entry's closing brace), or ``None`` if no entry with that
+    key is found.
+    """
+    # Match e.g. ``@misc{the-key,`` allowing arbitrary surrounding whitespace
+    pattern = re.compile(
+        r"@\w+\s*\{\s*" + re.escape(entry_id) + r"\s*,", re.IGNORECASE
+    )
+    match = pattern.search(text)
+    if match is None:
+        return None
+    # Walk from the entry's opening brace to its matching close, counting depth
+    depth = 0
+    i = text.index("{", match.start())
+    while i < len(text):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                return match.start(), i + 1
+        i += 1
+    return None
+
+
+def add_bibtex_entry(
+    existing_text: str, new_entry: str, replace_ids: list[str] | None = None
+) -> str:
+    """Append a BibTeX entry to existing references without reformatting them.
+
+    Any entries whose citation keys are in ``replace_ids`` are removed first
+    (so a re-released version replaces its prior entry); all other existing
+    content is preserved byte-for-byte. ``new_entry`` is appended at the end.
+    """
+    text = existing_text
+    # Remove replaced entries from the raw text, last-to-first so earlier spans
+    # stay valid as we splice. De-duplicate spans in case a key matched more
+    # than once.
+    spans = set()
+    for entry_id in replace_ids or []:
+        span = _find_bibtex_entry_span(text, entry_id)
+        if span is not None:
+            spans.add(span)
+    for start, end in sorted(spans, reverse=True):
+        # Consume any trailing newlines so we don't leave a gap behind
+        while end < len(text) and text[end] in "\r\n":
+            end += 1
+        text = text[:start] + text[end:]
+    # Append the new entry, leaving the existing content untouched and adding
+    # only the separator newlines needed for exactly one blank line between the
+    # last existing entry and the new one
+    if not text.strip():
+        return new_entry.strip() + "\n"
+    if text.endswith("\n\n"):
+        separator = ""
+    elif text.endswith("\n"):
+        separator = "\n"
+    else:
+        separator = "\n\n"
+    return text + separator + new_entry.strip() + "\n"
+
+
+def add_doi_badge_to_readme(
+    readme_text: str, badge: str, title: str | None
+) -> str:
+    """Insert (or refresh) a DOI badge near the top of a README.
+
+    The badge is placed directly beneath the title with exactly one blank line
+    on either side. Any pre-existing DOI badge line is replaced rather than
+    duplicated, the title is never duplicated, and all other existing content
+    is preserved.
+    """
+    # Drop any existing DOI badge line(s); the current badge is re-added below
+    lines = [
+        line
+        for line in (readme_text.split("\n") if readme_text else [])
+        if not line.startswith("[![DOI")
+    ]
+    # The first non-blank line is treated as the title; synthesize one from the
+    # project title if the README has no content yet
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    if lines:
+        title_line = lines[0]
+        rest = lines[1:]
+    else:
+        title_line = f"# {title}"
+        rest = []
+    # Drop leading blank lines from the remaining content so the spacing around
+    # the badge is controlled entirely here
+    while rest and not rest[0].strip():
+        rest.pop(0)
+    new_lines = [title_line, "", badge]
+    if rest:
+        new_lines += [""] + rest
+    return "\n".join(new_lines)
+
+
 CITATION_CFF_TEMPLATE = """
 cff-version: 1.2.0
 message: If you use this software, please cite it using these metadata.

{calkit_python-0.41.8 → calkit_python-0.41.9}/calkit/tests/cli/test_new.py

@@ -810,6 +810,21 @@ def test_new_release(tmp_dir, monkeypatch, httpserver):
     assert "v0.1.0" in ck_info["releases"]
     release = ck_info["releases"]["v0.1.0"]
     assert release["doi"] is not None
+    # Regression test for issue #931: the README must not be emptied, the
+    # committed README must match the working tree (otherwise it shows up as a
+    # spurious unstaged change), and the DOI badge must link to doi.org rather
+    # than the DataCite staging host (which 502s)
+    repo = git.Repo()
+    readme_working = (tmp_dir / "README.md").read_text()
+    assert readme_working.strip()
+    readme_committed = repo.git.show("HEAD:README.md")
+    assert readme_committed.strip() == readme_working.strip()
+    badge_link = f"](https://doi.org/{release['doi']})"
+    assert badge_link in readme_working
+    assert "datacite.org" not in readme_working
+    # The release BibTeX entry should be added to references.bib
+    references = (tmp_dir / "references.bib").read_text()
+    assert release["doi"] in references
     # TODO: Test that the GitHub link is in the related works
     # Test that we can update this release
     # Side note: This is revealing some design weirdness where we're grouping

{calkit_python-0.41.8 → calkit_python-0.41.9}/calkit/tests/test_releases.py

@@ -12,6 +12,8 @@ import pytest
 import calkit
 from calkit.dvc.zip import write_zip_path_map
 from calkit.releases import (
+    add_bibtex_entry,
+    add_doi_badge_to_readme,
     check_project_release_archive,
     create_bibtex,
     create_citation_cff,
@@ -163,6 +165,89 @@ def test_create_bibtex():
     assert len(entries) == 1
 
 
+def test_add_bibtex_entry():
+    new_entry = create_bibtex(
+        authors=[{"first_name": "Jane", "last_name": "Doe"}],
+        release_date="2026-06-03",
+        title="New release",
+        doi="10.5281/zenodo.999",
+        record_id="999",
+    )
+    # Appending to existing references preserves the original formatting
+    # (e.g., tab-indented fields) byte-for-byte and only adds the new entry
+    existing = (
+        "@article{smith2020,\n"
+        "\tauthor = {Smith, John},\n"
+        "\tdoi = {10.1/abc},\n"
+        "}\n"
+    )
+    appended = add_bibtex_entry(existing, new_entry, replace_ids=[])
+    # The existing content is preserved byte-for-byte at the start, with a
+    # single blank line separating it from the appended entry
+    assert appended.startswith(existing)
+    assert appended == existing + "\n" + new_entry.strip() + "\n"
+    assert appended.count("@misc{Doe2026_999,") == 1
+    assert bibtexparser.loads(appended).entries[0]["doi"] == "10.1/abc"
+    # Appending to an empty/nonexistent file yields just the new entry
+    from_empty = add_bibtex_entry("", new_entry, replace_ids=[])
+    assert from_empty.strip().startswith("@misc{Doe2026_999,")
+    # A matching entry (by citation key) is replaced, while other entries are
+    # left untouched and keep their original formatting
+    with_old = existing + (
+        "\n@misc{old2021,\n"
+        "\tauthor = {Doe, Jane},\n"
+        "\ttitle = {Old release},\n"
+        "\tdoi = {10.5281/zenodo.999},\n"
+        "}\n"
+    )
+    replaced = add_bibtex_entry(with_old, new_entry, replace_ids=["old2021"])
+    assert "Old release" not in replaced
+    assert "@article{smith2020,\n\tauthor = {Smith, John}," in replaced
+    assert replaced.count("@misc{Doe2026_999,") == 1
+
+
+def test_add_doi_badge_to_readme():
+    badge = "[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.999.svg)](https://doi.org/10.5281/zenodo.999)"  # noqa: E501
+    # A README with a title and body gets the badge inserted directly beneath
+    # the title with exactly one blank line on either side, and no content is
+    # removed or duplicated
+    readme = "# My Project\nSome description.\n\n## Section\nDetails here.\n"
+    out = add_doi_badge_to_readme(readme, badge=badge, title="My Project")
+    assert out.startswith(f"# My Project\n\n{badge}\n\nSome description.")
+    assert out.count("# My Project\n") == 1
+    assert "Some description." in out
+    assert "## Section" in out
+    assert "Details here." in out
+    # The badge has exactly one blank line above and below it
+    lines = out.split("\n")
+    idx = lines.index(badge)
+    assert lines[idx - 1] == ""
+    assert lines[idx - 2] == "# My Project"
+    assert lines[idx + 1] == ""
+    assert lines[idx + 2].strip()
+    # A title-only README does not duplicate the title
+    title_only = add_doi_badge_to_readme(
+        "# My Project\n", badge=badge, title="My Project"
+    )
+    assert title_only == f"# My Project\n\n{badge}"
+    # An empty/missing README falls back to the provided project title
+    from_empty = add_doi_badge_to_readme("", badge=badge, title="My Project")
+    assert from_empty == f"# My Project\n\n{badge}"
+    # An existing DOI badge is replaced, not duplicated, and sibling badges are
+    # preserved in place
+    other_badge = "[![CI](https://example.com/ci.svg)](https://example.com)"
+    old_badge = "[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.111.svg)](https://doi.org/10.5281/zenodo.111)"  # noqa: E501
+    with_old = f"# My Project\n{other_badge}\n\n{old_badge}\n\nBody.\n"
+    refreshed = add_doi_badge_to_readme(
+        with_old, badge=badge, title="My Project"
+    )
+    assert refreshed.count("[![DOI](") == 1
+    assert badge in refreshed
+    assert "zenodo.111" not in refreshed
+    assert other_badge in refreshed
+    assert "Body." in refreshed
+
+
 def test_read_authors_from_cff(tmp_dir):
     # No file present yields an empty list
     assert read_authors_from_cff() == []