martinpdes-maintenance 0.2.0__tar.gz

martinpdes_maintenance-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Martin Poinsinet de Sivry-Houle
+
+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.

martinpdes_maintenance-0.2.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: martinpdes-maintenance
+Version: 0.2.0
+Summary: Shared release preparation and metadata checks for scientific Python projects
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2; python_version < "3.11"
+Provides-Extra: testing
+Requires-Dist: pytest<10,>=8; extra == "testing"
+Requires-Dist: setuptools-scm<10,>=8; extra == "testing"
+Provides-Extra: scm
+Requires-Dist: setuptools-scm<10,>=8; extra == "scm"
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff==0.17.2; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=6; extra == "dev"
+Dynamic: license-file
+
+# martinpdes-maintenance
+
+Shared release preparation for the MartinPdeS scientific Python ecosystem.
+The distribution is `martinpdes-maintenance`; its command is `mps-maintenance`.
+Python 3.10 and newer are supported. The Python package lives directly in
+`martinpdes_maintenance/`, following the flat layout used by MartinPdeS-docs.
+
+## Install
+
+From a source checkout:
+
+```sh
+python -m pip install -e ".[dev,scm]"
+```
+
+This repository has not yet been published on PyPI. After publication, consumers
+can pin a reviewed version in their release development extra. The tool is not
+a runtime dependency of scientific packages.
+
+## Configure a consuming project
+
+Add explicit settings to the consumer's `pyproject.toml`:
+
+```toml
+[tool.mps-maintenance]
+version-file = "DeepPeak/_version.py"
+version-method = "setuptools-scm"
+conda-recipe = "conda.recipe/meta.yaml"
+```
+
+Use `version-method = "literal"` (the default) to update a simple
+`__version__ = version = "X.Y.Z"` assignment directly. SCM mode requires this
+tool's `scm` extra and generates the file using setuptools-scm. Optional settings:
+
+```toml
+zenodo = ".zenodo.json"
+citation = "CITATION.cff"
+```
+
+All configured files must already exist inside the repository. Unknown settings
+are errors. Project versions must be static in `[project].version`; Conda recipes
+must contain one literal `version:` field. Jinja-templated recipe versions and
+prerelease creation are not supported in this initial implementation. Citation
+updates currently change the version only, preserving existing date behavior.
+
+## Commands
+
+Run from the consumer repository root, or supply `--root /path/to/repository`
+before the subcommand:
+
+```sh
+mps-maintenance check
+mps-maintenance check --version v1.2.3
+mps-maintenance next patch
+mps-maintenance tag v1.2.4 --dry-run
+```
+
+`next` selects the highest stable `vMAJOR.MINOR.PATCH` tag available locally,
+including tags not reachable from HEAD. It ignores prerelease and unrelated tags;
+fetch tags first when remote releases may be missing. It fails if no stable tag exists.
+
+`tag` requires a clean, full Git checkout and an unused stable tag. It calculates
+all replacements before writing, prints a diff, validates updated versions,
+stages the release files, commits, then creates an annotated tag. `--dry-run`
+prints the plan without writing repository files, staging, committing, or tagging.
+Zenodo publication dates default to the local calendar date; `--date YYYY-MM-DD`
+sets a reproducible date explicitly.
+
+To actually create the release commit and tag, omit `--dry-run`. Nothing is
+pushed. Existing Makefile push behavior should remain in the consumer repository.
+A commit or tag failure leaves state for inspection: use `git status` and
+`git log -1`, fix the cause, and recover explicitly. A tag failure can leave a
+successful release commit. Do not blindly rerun or reset unrelated work.
+
+## Migration
+
+1. Install a reviewed tool revision in the release environment.
+2. Configure every file the old scripts check or update.
+3. Compare `check`, `next`, and dry-run output with the old scripts.
+4. Replace old script bodies with thin CLI wrappers, preserving Makefile behavior.
+5. Verify in a disposable clone before removing compatibility wrappers.
+
+DeepPeak uses SCM generation; PyMieSim and PackLab additionally update Zenodo;
+BornSim uses literal generation plus Zenodo and Citation metadata. No consumer
+repositories are migrated automatically.
+
+## Development
+
+```sh
+python -m pytest
+python -m ruff check .
+python -m ruff format --check .
+python -m build
+python -m twine check dist/*
+```
+
+Tests create local temporary Git repositories and never push or publish.
+See CONTRIBUTING.md for release bootstrapping.

martinpdes_maintenance-0.2.0/README.md

@@ -0,0 +1,98 @@
+# martinpdes-maintenance
+
+Shared release preparation for the MartinPdeS scientific Python ecosystem.
+The distribution is `martinpdes-maintenance`; its command is `mps-maintenance`.
+Python 3.10 and newer are supported. The Python package lives directly in
+`martinpdes_maintenance/`, following the flat layout used by MartinPdeS-docs.
+
+## Install
+
+From a source checkout:
+
+```sh
+python -m pip install -e ".[dev,scm]"
+```
+
+This repository has not yet been published on PyPI. After publication, consumers
+can pin a reviewed version in their release development extra. The tool is not
+a runtime dependency of scientific packages.
+
+## Configure a consuming project
+
+Add explicit settings to the consumer's `pyproject.toml`:
+
+```toml
+[tool.mps-maintenance]
+version-file = "DeepPeak/_version.py"
+version-method = "setuptools-scm"
+conda-recipe = "conda.recipe/meta.yaml"
+```
+
+Use `version-method = "literal"` (the default) to update a simple
+`__version__ = version = "X.Y.Z"` assignment directly. SCM mode requires this
+tool's `scm` extra and generates the file using setuptools-scm. Optional settings:
+
+```toml
+zenodo = ".zenodo.json"
+citation = "CITATION.cff"
+```
+
+All configured files must already exist inside the repository. Unknown settings
+are errors. Project versions must be static in `[project].version`; Conda recipes
+must contain one literal `version:` field. Jinja-templated recipe versions and
+prerelease creation are not supported in this initial implementation. Citation
+updates currently change the version only, preserving existing date behavior.
+
+## Commands
+
+Run from the consumer repository root, or supply `--root /path/to/repository`
+before the subcommand:
+
+```sh
+mps-maintenance check
+mps-maintenance check --version v1.2.3
+mps-maintenance next patch
+mps-maintenance tag v1.2.4 --dry-run
+```
+
+`next` selects the highest stable `vMAJOR.MINOR.PATCH` tag available locally,
+including tags not reachable from HEAD. It ignores prerelease and unrelated tags;
+fetch tags first when remote releases may be missing. It fails if no stable tag exists.
+
+`tag` requires a clean, full Git checkout and an unused stable tag. It calculates
+all replacements before writing, prints a diff, validates updated versions,
+stages the release files, commits, then creates an annotated tag. `--dry-run`
+prints the plan without writing repository files, staging, committing, or tagging.
+Zenodo publication dates default to the local calendar date; `--date YYYY-MM-DD`
+sets a reproducible date explicitly.
+
+To actually create the release commit and tag, omit `--dry-run`. Nothing is
+pushed. Existing Makefile push behavior should remain in the consumer repository.
+A commit or tag failure leaves state for inspection: use `git status` and
+`git log -1`, fix the cause, and recover explicitly. A tag failure can leave a
+successful release commit. Do not blindly rerun or reset unrelated work.
+
+## Migration
+
+1. Install a reviewed tool revision in the release environment.
+2. Configure every file the old scripts check or update.
+3. Compare `check`, `next`, and dry-run output with the old scripts.
+4. Replace old script bodies with thin CLI wrappers, preserving Makefile behavior.
+5. Verify in a disposable clone before removing compatibility wrappers.
+
+DeepPeak uses SCM generation; PyMieSim and PackLab additionally update Zenodo;
+BornSim uses literal generation plus Zenodo and Citation metadata. No consumer
+repositories are migrated automatically.
+
+## Development
+
+```sh
+python -m pytest
+python -m ruff check .
+python -m ruff format --check .
+python -m build
+python -m twine check dist/*
+```
+
+Tests create local temporary Git repositories and never push or publish.
+See CONTRIBUTING.md for release bootstrapping.

martinpdes_maintenance-0.2.0/martinpdes_maintenance/__init__.py

@@ -0,0 +1 @@
+"""Shared, explicitly configured repository maintenance tools."""

martinpdes_maintenance-0.2.0/martinpdes_maintenance/cli.py

@@ -0,0 +1,223 @@
+"""Command-line release operations; publishing remains the caller's responsibility."""
+
+import argparse
+import difflib
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from datetime import date
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+TAG = re.compile(r"v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)")
+
+
+def git(root, *args):
+    """Run Git in the explicit repository and return its output."""
+    return subprocess.run(
+        ["git", "-C", str(root), *args], check=True, capture_output=True, text=True
+    ).stdout.strip()
+
+
+def load(root):
+    """Load project metadata and validate explicitly configured release paths."""
+    project = tomllib.loads((root / "pyproject.toml").read_text())
+    config = project.get("tool", {}).get("mps-maintenance", {})
+    allowed = {"version-file", "version-method", "conda-recipe", "zenodo", "citation"}
+    if not config or set(config) - allowed:
+        raise ValueError("Configure [tool.mps-maintenance]; unknown settings are not allowed")
+    if config.get("version-method", "literal") not in {"literal", "setuptools-scm"}:
+        raise ValueError("version-method must be literal or setuptools-scm")
+    for key in allowed - {"version-method"}:
+        if key not in config:
+            continue
+        value = config[key]
+        if not isinstance(value, str) or not value:
+            raise ValueError(f"{key} must be a nonempty relative path")
+        path = root / value
+        if Path(value).is_absolute() or not path.resolve().is_relative_to(root):
+            raise ValueError(f"{key} must stay within the repository")
+        if not path.is_file() or path.is_symlink():
+            raise ValueError(f"{key} must name an existing regular file")
+    if "version-method" in config and "version-file" not in config:
+        raise ValueError("version-method requires version-file")
+    return project, config
+
+
+def replace(text, pattern, replacement):
+    """Require exactly one matching metadata field."""
+    if len(list(re.finditer(pattern, text, re.MULTILINE))) != 1:
+        raise ValueError(f"Expected exactly one field matching {pattern}")
+    return re.sub(pattern, replacement, text, flags=re.MULTILINE)
+
+
+def fields(root, config):
+    """Return configured version fields and their regular expressions."""
+    result = {"pyproject.toml": r'(?m)(^version\s*=\s*)["\']([^"\']+)["\']'}
+    for key, pattern in {
+        "version-file": r'(^__version__\s*=\s*version\s*=\s*)["\']([^"\']+)["\']',
+        "conda-recipe": r'(^[ \t]*version:[ \t]*)["\']?([^\s"\'#]+)["\']?',
+        "citation": r'(^version:[ \t]*)["\']?([^\s"\'#]+)["\']?',
+    }.items():
+        if key in config:
+            result[config[key]] = pattern
+    return result
+
+
+def versions(root, config):
+    """Read every configured version, failing on missing or ambiguous fields."""
+    result = {}
+    for path, pattern in fields(root, config).items():
+        if path == "pyproject.toml":
+            result[path] = str(tomllib.loads((root / path).read_text())["project"]["version"])
+            continue
+        matches = list(re.finditer(pattern, (root / path).read_text(), re.MULTILINE))
+        if len(matches) != 1:
+            raise ValueError(f"Expected exactly one version in {path}")
+        result[path] = matches[0].group(2)
+    if "zenodo" in config:
+        result[config["zenodo"]] = json.loads((root / config["zenodo"]).read_text())["version"]
+    return result
+
+
+def plan(root, config, version, release_date):
+    """Prepare all new file contents before writing any release metadata."""
+    versions(root, config)
+    updates = {}
+    for path, pattern in fields(root, config).items():
+        text = (root / path).read_text()
+        if path == "pyproject.toml":
+            # Restrict replacement to the project table, never a tool's version setting.
+            table = re.search(r"(?ms)^\[project\][ \t]*\n.*?(?=^\[|\Z)", text)
+            if table is None:
+                raise ValueError("Missing [project] table")
+            section = replace(table[0], pattern, lambda m: m[1] + json.dumps(version))
+            updates[path] = text[: table.start()] + section + text[table.end() :]
+        else:
+            updates[path] = replace(text, pattern, lambda m: m[1] + json.dumps(version))
+    if "zenodo" in config:
+        path = config["zenodo"]
+        data = json.loads((root / path).read_text())
+        data.update(version=version, publication_date=release_date)
+        updates[path] = json.dumps(data, indent=2) + "\n"
+    if config.get("version-method") == "setuptools-scm":
+        # Generate into a temporary destination, keeping planning read-only for the repository.
+        with tempfile.TemporaryDirectory() as directory:
+            destination = Path(directory) / "_version.py"
+            subprocess.run(
+                [
+                    sys.executable,
+                    "-c",
+                    (
+                        "from setuptools_scm import get_version; "
+                        "import sys; get_version(root=sys.argv[1], write_to=sys.argv[2], "
+                        "version_scheme='only-version', local_scheme='no-local-version')"
+                    ),
+                    str(Path(directory).resolve()),
+                    str(destination.resolve()),
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+                env={**os.environ, "SETUPTOOLS_SCM_PRETEND_VERSION": version},
+            )
+            updates[config["version-file"]] = destination.read_text()
+    return updates
+
+
+def main(argv=None):
+    """Execute a release command and return a shell exit status."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path.cwd())
+    commands = parser.add_subparsers(dest="command", required=True)
+    commands.add_parser("next").add_argument("kind", choices=["major", "minor", "patch"])
+    check = commands.add_parser("check")
+    check.add_argument("--version")
+    tag = commands.add_parser("tag")
+    tag.add_argument("tag")
+    tag.add_argument("--dry-run", action="store_true")
+    tag.add_argument("--date", default=date.today().isoformat())
+    args = parser.parse_args(argv)
+    root = args.root.resolve()
+    try:
+        if Path(git(root, "rev-parse", "--show-toplevel")).resolve() != root:
+            raise ValueError("--root must be the Git repository root")
+        if args.command == "next":
+            tags = [
+                tuple(map(int, m.groups()))
+                for t in git(root, "tag", "--list").splitlines()
+                if (m := TAG.fullmatch(t))
+            ]
+            if not tags:
+                raise ValueError("No stable semantic-version tag found")
+            numbers = list(max(tags))
+            index = ["major", "minor", "patch"].index(args.kind)
+            numbers[index] += 1
+            numbers[index + 1 :] = [0] * (2 - index)
+            print("v" + ".".join(map(str, numbers)))
+            return 0
+        _, config = load(root)
+        if args.command == "check":
+            declared = versions(root, config)
+            expected = (args.version or declared["pyproject.toml"]).removeprefix("v")
+            for path, value in declared.items():
+                print(f"{'OK' if value == expected else 'MISMATCH'} {path}: {value}")
+            return int(any(value != expected for value in declared.values()))
+        match = TAG.fullmatch(args.tag)
+        if not match:
+            raise ValueError("Tag must use vMAJOR.MINOR.PATCH")
+        date.fromisoformat(args.date)
+        if git(root, "status", "--porcelain", "--untracked-files=all"):
+            raise ValueError("Working tree must be clean")
+        if git(root, "tag", "--list", args.tag):
+            raise ValueError("Tag already exists")
+        if git(root, "rev-parse", "--is-shallow-repository") == "true":
+            raise ValueError("Release creation requires a full clone")
+        updates = plan(root, config, args.tag[1:], args.date)
+        for path, text in updates.items():
+            print(
+                "".join(
+                    difflib.unified_diff(
+                        (root / path).read_text().splitlines(True),
+                        text.splitlines(True),
+                        fromfile=path,
+                        tofile=path,
+                    )
+                ),
+                end="",
+            )
+        if args.dry_run:
+            return 0
+        originals = {path: (root / path).read_bytes() for path in updates}
+        try:
+            for path, text in updates.items():
+                (root / path).write_text(text)
+            if any(v != args.tag[1:] for v in versions(root, config).values()):
+                raise ValueError("Updated metadata failed validation")
+        except Exception:
+            for path, content in originals.items():
+                (root / path).write_bytes(content)
+            raise
+        git(root, "add", "--", *updates)
+        git(root, "commit", "-m", f"Release {args.tag}")
+        git(root, "tag", "-a", args.tag, "-m", f"Release {args.tag}")
+        print(f"Created {args.tag}; nothing was pushed.")
+        return 0
+    except (ValueError, KeyError, OSError, subprocess.CalledProcessError) as error:
+        print(f"Release operation failed: {error}", file=sys.stderr)
+        print(
+            "Inspect git status and git log before retrying a failed tag operation.",
+            file=sys.stderr,
+        )
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: martinpdes-maintenance
+Version: 0.2.0
+Summary: Shared release preparation and metadata checks for scientific Python projects
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2; python_version < "3.11"
+Provides-Extra: testing
+Requires-Dist: pytest<10,>=8; extra == "testing"
+Requires-Dist: setuptools-scm<10,>=8; extra == "testing"
+Provides-Extra: scm
+Requires-Dist: setuptools-scm<10,>=8; extra == "scm"
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff==0.17.2; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: twine<7,>=6; extra == "dev"
+Dynamic: license-file
+
+# martinpdes-maintenance
+
+Shared release preparation for the MartinPdeS scientific Python ecosystem.
+The distribution is `martinpdes-maintenance`; its command is `mps-maintenance`.
+Python 3.10 and newer are supported. The Python package lives directly in
+`martinpdes_maintenance/`, following the flat layout used by MartinPdeS-docs.
+
+## Install
+
+From a source checkout:
+
+```sh
+python -m pip install -e ".[dev,scm]"
+```
+
+This repository has not yet been published on PyPI. After publication, consumers
+can pin a reviewed version in their release development extra. The tool is not
+a runtime dependency of scientific packages.
+
+## Configure a consuming project
+
+Add explicit settings to the consumer's `pyproject.toml`:
+
+```toml
+[tool.mps-maintenance]
+version-file = "DeepPeak/_version.py"
+version-method = "setuptools-scm"
+conda-recipe = "conda.recipe/meta.yaml"
+```
+
+Use `version-method = "literal"` (the default) to update a simple
+`__version__ = version = "X.Y.Z"` assignment directly. SCM mode requires this
+tool's `scm` extra and generates the file using setuptools-scm. Optional settings:
+
+```toml
+zenodo = ".zenodo.json"
+citation = "CITATION.cff"
+```
+
+All configured files must already exist inside the repository. Unknown settings
+are errors. Project versions must be static in `[project].version`; Conda recipes
+must contain one literal `version:` field. Jinja-templated recipe versions and
+prerelease creation are not supported in this initial implementation. Citation
+updates currently change the version only, preserving existing date behavior.
+
+## Commands
+
+Run from the consumer repository root, or supply `--root /path/to/repository`
+before the subcommand:
+
+```sh
+mps-maintenance check
+mps-maintenance check --version v1.2.3
+mps-maintenance next patch
+mps-maintenance tag v1.2.4 --dry-run
+```
+
+`next` selects the highest stable `vMAJOR.MINOR.PATCH` tag available locally,
+including tags not reachable from HEAD. It ignores prerelease and unrelated tags;
+fetch tags first when remote releases may be missing. It fails if no stable tag exists.
+
+`tag` requires a clean, full Git checkout and an unused stable tag. It calculates
+all replacements before writing, prints a diff, validates updated versions,
+stages the release files, commits, then creates an annotated tag. `--dry-run`
+prints the plan without writing repository files, staging, committing, or tagging.
+Zenodo publication dates default to the local calendar date; `--date YYYY-MM-DD`
+sets a reproducible date explicitly.
+
+To actually create the release commit and tag, omit `--dry-run`. Nothing is
+pushed. Existing Makefile push behavior should remain in the consumer repository.
+A commit or tag failure leaves state for inspection: use `git status` and
+`git log -1`, fix the cause, and recover explicitly. A tag failure can leave a
+successful release commit. Do not blindly rerun or reset unrelated work.
+
+## Migration
+
+1. Install a reviewed tool revision in the release environment.
+2. Configure every file the old scripts check or update.
+3. Compare `check`, `next`, and dry-run output with the old scripts.
+4. Replace old script bodies with thin CLI wrappers, preserving Makefile behavior.
+5. Verify in a disposable clone before removing compatibility wrappers.
+
+DeepPeak uses SCM generation; PyMieSim and PackLab additionally update Zenodo;
+BornSim uses literal generation plus Zenodo and Citation metadata. No consumer
+repositories are migrated automatically.
+
+## Development
+
+```sh
+python -m pytest
+python -m ruff check .
+python -m ruff format --check .
+python -m build
+python -m twine check dist/*
+```
+
+Tests create local temporary Git repositories and never push or publish.
+See CONTRIBUTING.md for release bootstrapping.

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+martinpdes_maintenance/__init__.py
+martinpdes_maintenance/cli.py
+martinpdes_maintenance.egg-info/PKG-INFO
+martinpdes_maintenance.egg-info/SOURCES.txt
+martinpdes_maintenance.egg-info/dependency_links.txt
+martinpdes_maintenance.egg-info/entry_points.txt
+martinpdes_maintenance.egg-info/requires.txt
+martinpdes_maintenance.egg-info/top_level.txt
+tests/test_cli.py

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mps-maintenance = martinpdes_maintenance.cli:main

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/requires.txt

@@ -0,0 +1,16 @@
+
+[:python_version < "3.11"]
+tomli>=2
+
+[dev]
+pytest<10,>=8
+ruff==0.17.2
+build<2,>=1
+twine<7,>=6
+
+[scm]
+setuptools-scm<10,>=8
+
+[testing]
+pytest<10,>=8
+setuptools-scm<10,>=8

martinpdes_maintenance-0.2.0/martinpdes_maintenance.egg-info/top_level.txt

@@ -0,0 +1 @@
+martinpdes_maintenance

martinpdes_maintenance-0.2.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "martinpdes-maintenance"
+version = "0.2.0"
+description = "Shared release preparation and metadata checks for scientific Python projects"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["tomli>=2; python_version < '3.11'"]
+
+[project.optional-dependencies]
+testing = ["pytest>=8,<10", "setuptools-scm>=8,<10"]
+scm = ["setuptools-scm>=8,<10"]
+dev = ["pytest>=8,<10", "ruff==0.17.2", "build>=1,<2", "twine>=6,<7"]
+
+[project.scripts]
+mps-maintenance = "martinpdes_maintenance.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["martinpdes_maintenance", "martinpdes_maintenance.*"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

martinpdes_maintenance-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

martinpdes_maintenance-0.2.0/tests/test_cli.py

@@ -0,0 +1,133 @@
+"""Exercise release behavior in isolated Git repositories."""
+
+import json
+import subprocess
+
+import pytest
+
+from martinpdes_maintenance.cli import main
+
+
+def git(root, *args):
+    return subprocess.run(
+        ["git", "-C", str(root), *args], check=True, capture_output=True, text=True
+    ).stdout.strip()
+
+
+@pytest.fixture
+def repo(tmp_path):
+    git(tmp_path, "init")
+    git(tmp_path, "config", "user.name", "Test")
+    git(tmp_path, "config", "user.email", "test@example.invalid")
+    (tmp_path / "pyproject.toml").write_text("""[project]
+name = "example"
+version = "1.2.3"
+[tool.mps-maintenance]
+version-file = "_version.py"
+conda-recipe = "meta.yaml"
+zenodo = ".zenodo.json"
+citation = "CITATION.cff"
+""")
+    (tmp_path / "_version.py").write_text('__version__ = version = "1.2.3"\n')
+    (tmp_path / "meta.yaml").write_text("package:\n  name: example\n  version: 1.2.3 # keep\n")
+    (tmp_path / "CITATION.cff").write_text('version: "1.2.3"\ntitle: Example\n')
+    (tmp_path / ".zenodo.json").write_text(json.dumps({"version": "1.2.3", "title": "Keep"}))
+    git(tmp_path, "add", ".")
+    git(tmp_path, "commit", "-m", "Initial")
+    git(tmp_path, "tag", "v1.2.3")
+    return tmp_path
+
+
+def call(repo, *args):
+    return main(["--root", str(repo), *args])
+
+
+def test_next_ignores_nonstable_tags(repo, capsys):
+    git(repo, "tag", "v9.0.0rc1")
+    git(repo, "tag", "v2.0.0")
+    assert call(repo, "next", "minor") == 0
+    assert capsys.readouterr().out.strip() == "v2.1.0"
+
+
+def test_check_reports_mismatch(repo, capsys):
+    assert call(repo, "check") == 0
+    (repo / "_version.py").write_text('__version__ = version = "0.0.1"\n')
+    assert call(repo, "check") == 1
+    assert "MISMATCH" in capsys.readouterr().out
+
+
+def test_dry_run_is_read_only(repo):
+    before = {p.name: p.read_bytes() for p in repo.iterdir() if p.is_file()}
+    head = git(repo, "rev-parse", "HEAD")
+    assert call(repo, "tag", "v1.2.4", "--dry-run") == 0
+    assert before == {p.name: p.read_bytes() for p in repo.iterdir() if p.is_file()}
+    assert git(repo, "rev-parse", "HEAD") == head
+    assert not git(repo, "tag", "--list", "v1.2.4")
+
+
+def test_release_updates_all_metadata_and_annotates_tag(repo):
+    assert call(repo, "tag", "v1.2.4", "--date", "2026-10-24") == 0
+    assert call(repo, "check", "--version", "v1.2.4") == 0
+    assert git(repo, "status", "--porcelain") == ""
+    assert git(repo, "cat-file", "-t", "refs/tags/v1.2.4") == "tag"
+    metadata = json.loads((repo / ".zenodo.json").read_text())
+    assert metadata == {"version": "1.2.4", "title": "Keep", "publication_date": "2026-10-24"}
+    assert "# keep" in (repo / "meta.yaml").read_text()
+
+
+@pytest.mark.parametrize("reason", ["dirty", "existing", "invalid", "malformed", "escape"])
+def test_rejected_operations_do_not_change_head(repo, reason):
+    tag = "v1.2.4"
+    if reason == "dirty":
+        (repo / "unrelated").write_text("preserve")
+    elif reason == "existing":
+        tag = "v1.2.3"
+    elif reason == "invalid":
+        tag = "v01.2.4"
+    elif reason == "malformed":
+        (repo / "meta.yaml").write_text("not a recipe")
+        git(repo, "add", ".")
+        git(repo, "commit", "-m", "Malformed fixture")
+    else:
+        p = repo / "pyproject.toml"
+        p.write_text(p.read_text().replace('"_version.py"', '"../outside.py"'))
+        git(repo, "add", ".")
+        git(repo, "commit", "-m", "Invalid configuration")
+    head = git(repo, "rev-parse", "HEAD")
+    assert call(repo, "tag", tag) == 1
+    assert git(repo, "rev-parse", "HEAD") == head
+
+
+def test_scm_generation(repo):
+    pytest.importorskip("setuptools_scm")
+    p = repo / "pyproject.toml"
+    p.write_text(p.read_text() + 'version-method = "setuptools-scm"\n')
+    git(repo, "add", ".")
+    git(repo, "commit", "-m", "SCM configuration")
+    assert call(repo, "tag", "v1.2.4") == 0
+    assert call(repo, "check") == 0
+    assert "__version_tuple__" in (repo / "_version.py").read_text()
+
+
+def test_literal_project_without_optional_metadata(repo):
+    p = repo / "pyproject.toml"
+    p.write_text(
+        '[project]\nname="example"\nversion="1.2.3"\n'
+        '[tool.mps-maintenance]\nversion-file="_version.py"\n'
+    )
+    git(repo, "add", ".")
+    git(repo, "commit", "-m", "Minimal configuration")
+    assert call(repo, "tag", "v1.2.4") == 0
+    assert json.loads((repo / ".zenodo.json").read_text())["version"] == "1.2.3"
+
+
+def test_failed_commit_leaves_metadata_for_recovery(repo):
+    hook = repo / ".git" / "hooks" / "pre-commit"
+    hook.write_text("#!/bin/sh\nexit 1\n")
+    hook.chmod(0o755)
+    head = git(repo, "rev-parse", "HEAD")
+    assert call(repo, "tag", "v1.2.4") == 1
+    assert git(repo, "rev-parse", "HEAD") == head
+    assert git(repo, "tag", "--list", "v1.2.4") == ""
+    assert call(repo, "check", "--version", "v1.2.4") == 0
+    assert git(repo, "diff", "--cached", "--name-only")