calkit-python 0.41.6__tar.gz → 0.41.7__tar.gz

{calkit_python-0.41.6 → calkit_python-0.41.7}/AGENTS.md

@@ -22,6 +22,11 @@ not introduce new type errors.
 Wrap prose at natural breakpoints in phrases or punctuation to keep max
 line length below 80 characters.
 
+In the docs, MkDocs Material admonitions (`!!! note`, `!!! tip`, etc.) must be
+preceded by a `<!-- prettier-ignore -->` comment. Otherwise Prettier reformats
+the block and strips the 4-space indentation of the admonition body, which
+breaks rendering.
+
 Agents should never make commits to Git.
 
 Prefer tests that include multiple scenarios to comprehensively test
@@ -36,3 +41,5 @@ Functions should usually be used ~3 times before abstracting.
 Otherwise, split up long ones into logical sections with comments.
 The only exception here is if splitting up a function makes it easier to
 write meaningful unit tests.
+If a function is only used inside one other function, nest it inside the
+caller at the top.

{calkit_python-0.41.6 → calkit_python-0.41.7}/PKG-INFO

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

{calkit_python-0.41.6 → calkit_python-0.41.7}/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_python-0.41.6 → calkit_python-0.41.7}/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_python-0.41.6 → calkit_python-0.41.7}/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_python-0.41.7/calkit/licenses.py

@@ -0,0 +1,211 @@
+"""Functionality for working with licenses.
+
+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.).
+
+Source code (MIT License)
+
+All source code contained within this repository, including but not limited to
+files with the extensions .js, .py, .html, .css, .ts, .jsx, .tsx, shell
+scripts, build configurations, and their related files, is licensed under
+the MIT License.
+
+The MIT License (MIT)
+
+Copyright (c) {year} {copyright_holder}
+
+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.
+
+Content, data, and documentation (CC BY 4.0)
+
+All non-code assets, including but not limited to prose, documentation, data,
+figures, images, designs, and text written in Markdown or similar formats
+(e.g., files in a docs/ directory, this LICENSE file itself, or .txt files
+containing prose or data), are licensed under the Creative Commons Attribution
+4.0 International Public License (CC BY 4.0).
+
+To view a copy of this license, visit:
+
+CC BY 4.0 Deed (summary):
+https://creativecommons.org/licenses/by/4.0/
+
+CC BY 4.0 Legal Code (full license):
+https://creativecommons.org/licenses/by/4.0/legalcode
+
+This license requires you to give appropriate credit, provide a link to the
+license, and indicate if changes were made. You may do so in any reasonable
+manner, but not in any way that suggests the licensor endorses you or your use.
+""".strip()