calkit-python 0.41.6__py3-none-any.whl → 0.41.8__py3-none-any.whl

calkit/cli/main/core.py

@@ -2418,7 +2418,16 @@ def run_in_env(
             )
         # TODO: Prefix should only be in the env file or calkit.yaml, not both?
         prefix = env.get("prefix")
-        conda_cmd = ["conda", "run"]
+        # Conda is often not on the PATH (especially on Windows), so search
+        # typical install locations rather than relying on the bare name,
+        # which would fail with a confusing FileNotFoundError traceback.
+        conda_exe = calkit.conda.find_conda_exe()
+        if conda_exe is None:
+            raise_error(
+                "Cannot find Conda executable; "
+                "ensure Conda is installed and on the PATH"
+            )
+        conda_cmd = [conda_exe, "run"]
         if prefix is not None:
             conda_cmd += ["--prefix", os.path.abspath(prefix)]
         else:

calkit/cli/new.py

@@ -7,6 +7,7 @@ import os
 import pathlib
 import shutil
 import subprocess
+import time
 from enum import Enum
 
 import typer
@@ -3124,18 +3125,7 @@ def new_release(
     record_id = None
     # Detect project license IDs if necessary
     if not license_ids:
-        license_file = None
-        license_txt = None
-        license_candidates = [
-            "LICENSE",
-            "LICENSE.rst",
-            "LICENSE.txt",
-            "LICENSE.md",
-        ]
-        for lc in license_candidates:
-            if os.path.isfile(lc):
-                license_file = lc
-                break
+        license_file = calkit.licenses.find_license_file()
         if license_file is None:
             typer.echo("No project license found.")
             use_default_license = typer.confirm(
@@ -3155,15 +3145,18 @@ def new_release(
                 f.write(license_txt)
                 repo.git.add("LICENSE")
             license_ids = ["mit", "cc-by-4.0"]
-        if license_txt is None and license_file is not None:
+        else:
+            typer.echo(f"Detecting license(s) from {license_file}")
             with open(license_file) as f:
                 license_txt = f.read()
-            # Try to detect licenses
-            if "the mit license" in license_txt.lower():
-                license_ids.append("mit")
-            if "cc by 4.0" in license_txt.lower():
-                license_ids.append("cc-by-4.0")
-            # TODO: Detect others
+            license_ids = calkit.licenses.detect_license_ids(license_txt)
+            if license_ids:
+                typer.echo(f"Detected license(s): {', '.join(license_ids)}")
+            else:
+                warn(
+                    f"Could not detect any known license in {license_file}; "
+                    "specify one explicitly with --license"
+                )
     if not license_ids:
         raise_error("Project has no license(s) defined")
     invenio_metadata = dict(
@@ -3189,9 +3182,13 @@ def new_release(
         )
     invenio_metadata["related_identifiers"] = related_identifiers
     # TODO: Add calkit.io URL if applicable?
-    # Determine creators from authors, adding to project if not present
-    authors = ck_info.get("authors", [])
-    if not authors:
+    # Determine creators from authors. CITATION.cff is the single source of
+    # truth for authors, so read them from there; if none are defined yet,
+    # prompt for them and persist them to CITATION.cff.
+    authors = calkit.releases.read_authors_from_cff()
+    if authors:
+        typer.echo(f"Read {len(authors)} author(s) from CITATION.cff")
+    else:
         warn("No authors defined for the project")
         still_entering_authors = True
         n = 0
@@ -3218,24 +3215,27 @@ def new_release(
             still_entering_authors = typer.confirm(
                 "Are there more authors to enter?", default=True
             )
-        ck_info["authors"] = authors
-        # Write authors out to calkit.yaml
+        # Write authors out to CITATION.cff
         if not dry_run:
-            typer.echo("Adding authors to calkit.yaml")
-            with open("calkit.yaml", "w") as f:
-                calkit.ryaml.dump(ck_info, f)
+            typer.echo("Writing authors to CITATION.cff")
+            calkit.releases.set_cff_authors(authors, ck_info=ck_info)
+            repo.git.add("CITATION.cff")
     invenio_creators = []
     for author in authors:
         orcid = author.get("orcid")
-        creator = {
+        creator: dict = {
             "person_or_org": {
                 "type": "personal",
                 "given_name": author["first_name"],
                 "family_name": author["last_name"],
                 "identifiers": [{"identifier": orcid}] if orcid else [],
             },
-            "affiliations": [{"name": author["affiliation"]}],
         }
+        # Affiliation is optional (e.g., authors read from CITATION.cff may
+        # not specify one)
+        affiliation = author.get("affiliation")
+        if affiliation:
+            creator["affiliations"] = [{"name": affiliation}]
         invenio_creators.append(creator)
     invenio_metadata["creators"] = invenio_creators  # type: ignore
     # Set InvenioRDM resource_type based on release_type and artifact kind
@@ -3326,22 +3326,23 @@ def new_release(
                 f"/records/{record_id}/draft/files/{filename}/commit",
                 service=to,  # type: ignore
             )
-        # Conditionally publish or reserve DOI based on --draft flag
-        if draft_only:
-            # Reserve a DOI for the draft record
-            typer.echo(f"Reserving DOI for {to} draft record ID {record_id}")
-            doi_resp = calkit.invenio.post(
-                f"/records/{record_id}/draft/pids/doi",
-                service=to,  # type: ignore
+        # Reserve a DOI on the draft before publishing. The publish action's
+        # response only echoes back the DOI under "pids" if one was reserved
+        # on the draft first (otherwise "pids" comes back empty), so always
+        # reserve here to get a stable identifier.
+        typer.echo(f"Reserving DOI for {to} draft record ID {record_id}")
+        doi_resp = calkit.invenio.post(
+            f"/records/{record_id}/draft/pids/doi",
+            service=to,  # type: ignore
+        )
+        if verbose:
+            typer.echo(f"DOI reservation response:\n{doi_resp}")
+        doi = calkit.invenio.extract_doi(doi_resp)
+        if doi is None:
+            raise_error(
+                f"Failed to reserve DOI for {to} draft record {record_id}"
             )
-            if verbose:
-                typer.echo(f"DOI response for draft:\n{doi_resp}")
-            try:
-                doi = doi_resp["pids"]["doi"]["identifier"]
-            except KeyError:
-                doi = doi_resp["doi"]
-            except Exception as e:
-                raise_error(f"Failed to reserve DOI for draft: {e}")
+        if draft_only:
             url = f"https://doi.org/{doi}"
             typer.echo(f"Created {to} draft with reserved DOI: {doi}")
         else:
@@ -3351,8 +3352,37 @@ def new_release(
                 f"/records/{record_id}/draft/actions/publish",
                 service=to,  # type: ignore
             )
+            if verbose:
+                typer.echo(f"Publish response:\n{invenio_dep}")
             record_id = invenio_dep["id"]
-            doi = invenio_dep["pids"]["doi"]["identifier"]
+            # Prefer the DOI from the publish response, but fall back to the
+            # reserved DOI (and a fetch of the published record) since the
+            # publish action returns 202 and may not echo "pids" immediately.
+            # Polling failures are tolerated: we already have the reserved DOI,
+            # so a transient error while the record settles should not abort
+            # the release.
+            published_doi = calkit.invenio.extract_doi(invenio_dep)
+            for _ in range(10):
+                if published_doi is not None:
+                    break
+                time.sleep(1)
+                try:
+                    record = calkit.invenio.get(
+                        f"/records/{record_id}",
+                        service=to,  # type: ignore
+                    )
+                except Exception as e:
+                    if verbose:
+                        typer.echo(f"Polling for published DOI failed: {e}")
+                    continue
+                published_doi = calkit.invenio.extract_doi(record)
+            if published_doi is not None:
+                doi = published_doi
+            else:
+                typer.echo(
+                    "Could not confirm minted DOI from published record; "
+                    f"falling back to reserved DOI {doi}"
+                )
             url = f"https://doi.org/{doi}"
             typer.echo(f"Published to {to} with DOI: {doi}")
     else:
@@ -3423,10 +3453,13 @@ def new_release(
     )
     releases[name] = release
     ck_info["releases"] = releases
-    # Create CITATION.cff file
+    # Create/update CITATION.cff file, preserving existing authors
     if release_type == "project":
         cff = calkit.releases.create_citation_cff(
-            ck_info=ck_info, release_name=name, release_date=release_date
+            ck_info=ck_info,
+            release_name=name,
+            release_date=release_date,
+            authors=authors,
         )
         if dry_run:
             typer.echo(f"Would write CITATION.cff:\n{cff}")

calkit/cli/overleaf.py

@@ -12,9 +12,9 @@ import typer
 from typing_extensions import Annotated
 
 import calkit
-from calkit.cli import raise_error, warn
+from calkit.cli import AliasGroup, raise_error, warn
 
-overleaf_app = typer.Typer(no_args_is_help=True)
+overleaf_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
 
 
 def _extract_title_from_tex(tex_file_path: str) -> str | None:
@@ -369,8 +369,11 @@ def sync(
         typer.Option(
             "--no-commit",
             help=(
-                "Do not commit the changes to the project repo. "
-                "Changes will always be committed to Overleaf."
+                "Do not create a commit in the project repo for this sync. "
+                "Changes pulled from Overleaf are still applied, but are "
+                "left staged so you can review or commit them yourself. "
+                "Changes are always committed and pushed to Overleaf "
+                "regardless."
             ),
         ),
     ] = False,
@@ -378,6 +381,7 @@ def sync(
         bool,
         typer.Option(
             "--auto-commit",
+            "-a",
             help=(
                 "Automatically commit changes to the project repo if a synced "
                 "folder has changes."
@@ -490,8 +494,9 @@ def sync(
                 )
             else:
                 raise_error(
-                    f"Uncommitted changes found in {wdir}; "
-                    "please commit or stash them before syncing with Overleaf"
+                    f"Uncommitted changes found in {wdir}. "
+                    "Commit or stash them before syncing with Overleaf, "
+                    "or use --auto-commit/-a to automatically commit them."
                 )
         # Ensure we've cloned the Overleaf project
         overleaf_project_dir = os.path.join(
@@ -585,7 +590,7 @@ def compare_folders_recursively(
     return res
 
 
-@overleaf_app.command(name="status")
+@overleaf_app.command(name="status|st")
 def get_status(
     paths: Annotated[
         list[str] | None,

calkit/core.py

@@ -50,6 +50,7 @@ AUTO_IGNORE_SUFFIXES = [
     ".env",
     ".pyc",
     ".synctex.gz",
+    ".auxlock",
     ".ipynb_checkpoints",
 ]
 AUTO_IGNORE_PATHS = [os.path.join(".dvc", "config.local")]
@@ -340,6 +341,14 @@ def check_dep_exists(
         return True
     if system_info is not None and system_info.get(f"{name}_version"):
         return True
+    # Conda and mamba are frequently installed but not on the PATH (most
+    # commonly on Windows), so search their typical install locations
+    # rather than relying on the bare name being directly executable.
+    if name in ("conda", "mamba"):
+        from calkit.conda import find_conda_exe, find_mamba_exe
+
+        exe = find_conda_exe() if name == "conda" else find_mamba_exe()
+        return exe is not None
     cmd = [name]
     # Executables with non-conventional CLIs
     if name == "matlab":

calkit/invenio.py

@@ -107,6 +107,26 @@ put = partial(_request, "put")
 delete = partial(_request, "delete")
 
 
+def extract_doi(record: dict) -> str | None:
+    """Extract the DOI identifier from an InvenioRDM record or response.
+
+    Depending on the endpoint and whether the DOI has been minted yet, the
+    identifier can live in different places, so check all known locations and
+    return ``None`` if it isn't present yet.
+    """
+    pids = record.get("pids")
+    if isinstance(pids, dict):
+        doi = pids.get("doi")
+        if isinstance(doi, dict) and doi.get("identifier"):
+            return doi["identifier"]
+    if record.get("doi"):
+        return record["doi"]
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict) and metadata.get("doi"):
+        return metadata["doi"]
+    return None
+
+
 def get_download_urls(
     record_id: int | str,
     service: ServiceName = DEFAULT_SERVICE,

calkit/licenses.py

@@ -4,6 +4,158 @@ Calkit projects will often include code, data, text, and other content
 and artifacts that may each have their own license.
 """
 
+from __future__ import annotations
+
+import os
+import re
+
+# A list of (SPDX license ID, required substring groups) used to detect
+# licenses from the text of a license file.
+# Each entry maps an SPDX ID to a list of "all-of" groups; the license
+# matches if *every* group has at least one of its substrings present in the
+# (lowercased, whitespace-normalized) license text.
+# This is intentionally tolerant so that licenses written by hand, generated
+# by GitHub, or produced by Calkit's own templates are all detected.
+# A single license file may contain more than one license (e.g., Calkit's
+# default dual MIT/CC-BY-4.0 license), so all matching IDs are returned.
+_LICENSE_MARKERS: list[tuple[str, list[list[str]]]] = [
+    (
+        "mit",
+        [
+            [
+                "mit license",
+                "permission is hereby granted, free of charge, to any "
+                "person obtaining a copy",
+            ]
+        ],
+    ),
+    (
+        "apache-2.0",
+        [["apache license"], ["version 2.0", "version 2,"]],
+    ),
+    (
+        "bsd-3-clause",
+        [
+            ["redistribution and use in source and binary forms"],
+            ["neither the name of"],
+        ],
+    ),
+    (
+        "bsd-2-clause",
+        [
+            ["redistribution and use in source and binary forms"],
+        ],
+    ),
+    (
+        "gpl-3.0",
+        [["gnu general public license"], ["version 3"]],
+    ),
+    (
+        "gpl-2.0",
+        [["gnu general public license"], ["version 2"]],
+    ),
+    (
+        "lgpl-3.0",
+        [["gnu lesser general public license"], ["version 3"]],
+    ),
+    (
+        "agpl-3.0",
+        [["gnu affero general public license"], ["version 3"]],
+    ),
+    (
+        "mpl-2.0",
+        [["mozilla public license"], ["version 2.0", "version 2,"]],
+    ),
+    (
+        "cc-by-4.0",
+        [
+            [
+                "creative commons attribution 4.0",
+                "cc by 4.0",
+                "cc-by-4.0",
+                "creativecommons.org/licenses/by/4.0",
+            ]
+        ],
+    ),
+    (
+        "cc0-1.0",
+        [
+            [
+                "cc0 1.0",
+                "creative commons zero",
+                "creativecommons.org/publicdomain/zero/1.0",
+            ]
+        ],
+    ),
+    (
+        "isc",
+        [
+            [
+                "isc license",
+                "permission to use, copy, modify, and/or distribute this "
+                "software",
+            ]
+        ],
+    ),
+    (
+        "unlicense",
+        [
+            [
+                "this is free and unencumbered software released into the "
+                "public domain"
+            ]
+        ],
+    ),
+]
+
+# Candidate file names to search for a project license, in priority order.
+LICENSE_FILE_CANDIDATES = [
+    "LICENSE",
+    "LICENSE.txt",
+    "LICENSE.md",
+    "LICENSE.rst",
+    "LICENCE",
+    "LICENCE.txt",
+    "LICENCE.md",
+    "COPYING",
+]
+
+
+def detect_license_ids(text: str) -> list[str]:
+    """Detect SPDX license IDs present in license text.
+
+    The match is tolerant of whitespace and case, and a single body of text
+    can match multiple licenses (e.g., a dual-licensed project).
+    Returns the IDs in a deterministic order with duplicates removed.
+    """
+    if not text:
+        return []
+    # Lowercase and collapse all runs of whitespace so that line wrapping in
+    # the source license file does not break multi-word substring matches
+    normalized = re.sub(r"\s+", " ", text.lower())
+    found: list[str] = []
+    for license_id, groups in _LICENSE_MARKERS:
+        # The "bsd-3-clause" and "bsd-2-clause" markers overlap; only report
+        # the 2-clause variant when the 3-clause variant did not match
+        if license_id == "bsd-2-clause" and "bsd-3-clause" in found:
+            continue
+        if all(
+            any(substring in normalized for substring in group)
+            for group in groups
+        ):
+            found.append(license_id)
+    return found
+
+
+def find_license_file(wdir: str | None = None) -> str | None:
+    """Return the path to the project license file, if one exists."""
+    for candidate in LICENSE_FILE_CANDIDATES:
+        path = candidate if wdir is None else os.path.join(wdir, candidate)
+        if os.path.isfile(path):
+            return path
+    return None
+
+
 LICENSE_TEMPLATE_DUAL = """
 This project is licensed under a dual-license structure to appropriately cover
 both the software code and the non-code content (data, text, figures, etc.).