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

calkit/cli/new.py

@@ -3124,18 +3124,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 +3144,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 +3181,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 +3214,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
@@ -3423,10 +3422,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")]

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.).