calkit-python 0.35.5__tar.gz → 0.35.7__tar.gz

{calkit_python-0.35.5 → calkit_python-0.35.7}/PKG-INFO

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

{calkit_python-0.35.5 → calkit_python-0.35.7}/calkit/cli/main/core.py

@@ -55,7 +55,7 @@ from calkit.cli.office import office_app
 from calkit.cli.overleaf import overleaf_app
 from calkit.cli.slurm import slurm_app
 from calkit.cli.update import update_app
-from calkit.dvc import register_ck_scheme, run_dvc_command
+from calkit.dvc import get_dvc_repo, run_dvc_command
 from calkit.environments import get_env_lock_fpath
 from calkit.models import Procedure
 
@@ -252,10 +252,12 @@ def get_status(
 ):
     """View status (project, version control, and/or pipeline)."""
     ck_info = calkit.load_calkit_info()
-    try:
-        calkit.pipeline.to_dvc(ck_info=ck_info, write=True)
-    except Exception as e:
-        warn(f"Failed to compile pipeline: {e.__class__.__name__}: {e}")
+    # If there's anything in ck_info and this isn't a Git repo, initialize one
+    if ck_info:
+        try:
+            git.Repo()
+        except InvalidGitRepositoryError:
+            git.Repo.init()
     valid_categories = ["project", "git", "dvc", "pipeline"]
     if categories is not None:
         for category in categories:
@@ -266,11 +268,22 @@ def get_status(
                 )
     else:
         categories = valid_categories
-    # Clean all notebooks in the pipeline
-    try:
-        calkit.notebooks.clean_all_in_pipeline(ck_info=ck_info)
-    except Exception as e:
-        warn(f"Failed to clean notebooks: {e.__class__.__name__}: {e}")
+    pipeline_status = None
+    if "pipeline" in categories or "dvc" in categories:
+        pipeline_status = calkit.pipeline.get_status(
+            ck_info=ck_info,
+            targets=targets,
+            check_environments=True,
+            clean_notebooks=True,
+            compile_to_dvc=True,
+        )
+        for error in pipeline_status.errors:
+            warn(error)
+        if pipeline_status.failed_environment_checks:
+            warn(
+                "Failed pipeline environment checks for: "
+                + ", ".join(pipeline_status.failed_environment_checks)
+            )
     if "project" in categories:
         print_sep("Project")
         # Print latest status
@@ -307,10 +320,32 @@ def get_status(
         typer.echo()
     if "pipeline" in categories or "dvc" in categories:
         print_sep("Pipeline")
-        dvc_pipeline_cmd = ["status"]
-        if targets:
-            dvc_pipeline_cmd += targets
-        run_dvc_command(dvc_pipeline_cmd)
+        # Nicely format the results from pipeline status
+        if pipeline_status and pipeline_status.errors:
+            typer.echo("Pipeline status unavailable due to errors.")
+        elif pipeline_status and pipeline_status.is_stale:
+            for stage_name in pipeline_status.stale_stage_names:
+                stale_stage = pipeline_status.stale_stages.get(stage_name)
+                if stale_stage is None:
+                    continue
+                typer.echo(f"{typer.style(stage_name, fg='yellow')}:")
+                # Show stale outputs for this stage
+                if stale_stage.stale_outputs:
+                    typer.echo("  stale outputs:")
+                    for output_path in stale_stage.stale_outputs:
+                        typer.echo(f"    - {output_path}")
+                # Show modified outputs from this stage
+                if stale_stage.modified_outputs:
+                    typer.echo("  modified outputs:")
+                    for output_path in stale_stage.modified_outputs:
+                        typer.echo(f"    - {output_path}")
+                # Show modified inputs making the stage stale
+                if stale_stage.modified_inputs:
+                    typer.echo("  modified inputs:")
+                    for input_path in stale_stage.modified_inputs:
+                        typer.echo(f"    - {input_path}")
+        elif pipeline_status:
+            typer.echo("Pipeline is up to date.")
 
 
 @app.command(name="diff")
@@ -403,8 +438,7 @@ def add(
             raise_error("Not currently in a Git repo; run `calkit init` first")
         repo = git.Repo()
     try:
-        register_ck_scheme()
-        dvc_repo = dvc.repo.Repo()
+        dvc_repo = get_dvc_repo()
     except NotDvcRepoError:
         warn("DVC not initialized yet; initializing")
         dvc_repo = dvc.repo.Repo.init()
@@ -1139,10 +1173,8 @@ def run(
             os.environ.pop("CALKIT_PIPELINE_RUNNING", None)
             raise_error(f"Pipeline compilation failed: {e}")
     # Initialize DVC repo if necessary
-    # Register the ck:// scheme before accessing DVC repo
-    register_ck_scheme()
     try:
-        dvc.repo.Repo()
+        get_dvc_repo()
     except Exception:
         if not quiet:
             typer.echo("Initializing DVC repo")
@@ -1203,8 +1235,7 @@ def run(
         git_staged_files_before = calkit.git.get_staged_files(repo=repo)
         git_untracked_files_before = calkit.git.get_untracked_files(repo=repo)
         # Get status of DVC repo before running
-        register_ck_scheme()
-        dvc_repo = dvc.repo.Repo()
+        dvc_repo = get_dvc_repo()
         dvc_status_before = dvc_repo.status()
         dvc_data_status_before = dvc_repo.data_status()
         dvc_data_status_before.pop("git", None)  # Remove git status

{calkit_python-0.35.5 → calkit_python-0.35.7}/calkit/cli/new.py

@@ -17,6 +17,7 @@ from git.exc import GitCommandError, InvalidGitRepositoryError, NoSuchPathError
 from typing_extensions import Annotated
 
 import calkit
+import calkit.pipeline
 from calkit.cli import raise_error, warn
 from calkit.cli.check import check_environment
 from calkit.cli.update import update_devcontainer
@@ -2523,6 +2524,26 @@ def new_release(
     repo = git.Repo()
     if name in repo.tags:
         raise_error(f"Git tag with name '{name}' already exists")
+    # Check that the pipeline is up-to-date
+    typer.echo("Checking pipeline is up-to-date for release")
+    status = calkit.pipeline.get_status(
+        ck_info=ck_info,
+        check_environments=True,
+        clean_notebooks=True,
+        compile_to_dvc=True,
+    )
+    if status.errors:
+        raise_error("Pipeline checks failed: " + "; ".join(status.errors))
+    if status.failed_environment_checks:
+        raise_error(
+            "Pipeline environment checks failed for: "
+            + ", ".join(status.failed_environment_checks)
+        )
+    if status.is_stale:
+        raise_error(
+            "Pipeline is not up-to-date; out-of-date stages: "
+            + ", ".join(status.stale_stage_names)
+        )
     release_dir = f".calkit/releases/{name}"
     release_files_dir = release_dir + "/files"
     os.makedirs(release_files_dir, exist_ok=True)
@@ -2543,8 +2564,14 @@ def new_release(
         all_paths = calkit.releases.ls_files()
         typer.echo(f"Adding files to {zip_path}")
         with zipfile.ZipFile(zip_path, "w") as zipf:
-            for fpath in all_paths:
-                zipf.write(fpath)
+            calkit.releases.add_paths_to_zip(zipf, all_paths)
+        typer.echo("Checking extracted project release archive")
+        try:
+            calkit.releases.check_project_release_archive(
+                zip_path, verbose=verbose
+            )
+        except Exception as e:
+            raise_error(str(e))
         title = ck_info.get("title")
         if title is None:
             warn("Project has no title")
@@ -2888,10 +2915,12 @@ def new_release(
             + new_lines[first_content_line_index:]
         )
         readme_txt = "\n".join(new_lines)
-        with open("README.md", "w") as f:
-            f.write(readme_txt)
         if not dry_run:
-            repo.git.add("README.md")
+            with open("README.md", "w") as f:
+                f.write(readme_txt)
+                repo.git.add("README.md")
+        else:
+            typer.echo(f"Would have updated README.md to:\n{readme_txt}")
     # Create Git tag
     git_tag_message = release_description
     if git_tag_message is None:
@@ -2919,13 +2948,15 @@ def new_release(
     ck_info["releases"] = releases
     # Create CITATION.cff file
     if release_type == "project":
-        typer.echo("Writing CITATION.cff")
         cff = calkit.releases.create_citation_cff(
             ck_info=ck_info, release_name=name, release_date=release_date
         )
-        with open("CITATION.cff", "w") as f:
-            calkit.ryaml.dump(cff, f)
-        if not dry_run:
+        if dry_run:
+            typer.echo(f"Would write CITATION.cff:\n{cff}")
+        else:
+            typer.echo("Writing CITATION.cff")
+            with open("CITATION.cff", "w") as f:
+                calkit.ryaml.dump(cff, f)
             repo.git.add("CITATION.cff")
     # Add to references so it can be cited
     typer.echo("Adding BibTeX entry to references")
@@ -2944,28 +2975,50 @@ def new_release(
                 reflib = bibtexparser.load(f)
         else:
             reflib = bibtexparser.bibdatabase.BibDatabase()
+        bibtex_doi = doi
+        if bibtex_doi is None and dry_run:
+            mock_suffix = "".join(
+                ch if (ch.isalnum() or ch in ".-_") else "-"
+                for ch in name.lower()
+            )
+            bibtex_doi = f"10.0000/calkit-dry-run.{mock_suffix}"
         invenio_bibtex = calkit.releases.create_bibtex(
             authors=authors,
             release_date=release_date,
             title=title,  # type: ignore
-            doi=doi,  # type: ignore
+            doi=bibtex_doi,
             record_id=record_id,  # type: ignore
             service=to,  # type: ignore
         )
-        new_entry = bibtexparser.loads(invenio_bibtex).entries[0]
+        new_entries = bibtexparser.loads(invenio_bibtex).entries
+        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
-        existing_index = None
-        for n, entry in enumerate(reflib.entries):
-            if entry.get("doi") == doi:
-                typer.echo("Found matching DOI in existing references")
-                existing_index = n
-        if existing_index is not None:
-            _ = reflib.entries.pop(existing_index)
+        new_doi = new_entry.get("doi")
+        matching_indices = []
+        if new_doi:
+            matching_indices = [
+                n
+                for n, entry in enumerate(reflib.entries)
+                if entry.get("doi") == new_doi
+            ]
+        if matching_indices:
+            typer.echo(
+                "Found matching DOI in existing references "
+                f"({len(matching_indices)} entr"
+                f"{'y' if len(matching_indices) == 1 else 'ies'}); "
+                "replacing"
+            )
+            for n in reversed(matching_indices):
+                _ = reflib.entries.pop(n)
         reflib.entries.append(new_entry)
-        with open(ref_path, "w") as f:
-            bibtexparser.dump(reflib, f)
-        if not dry_run:
+        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)
             repo.git.add(ref_path)
     except Exception as e:
         warn(f"Failed to add to references: {e}")

{calkit_python-0.35.5 → calkit_python-0.35.7}/calkit/cli/update.py

@@ -12,6 +12,7 @@ import typer
 from typing_extensions import Annotated
 
 import calkit
+import calkit.pipeline
 from calkit.cli import raise_error
 
 update_app = typer.Typer(no_args_is_help=True)
@@ -156,6 +157,26 @@ def update_release(
     record_id = release.get("record_id")
     if record_id is None:
         raise_error("Release has no record ID")
+    if publish or reupload:
+        typer.echo("Checking pipeline is up-to-date for release update")
+        status = calkit.pipeline.get_status(
+            ck_info=ck_info,
+            check_environments=True,
+            clean_notebooks=True,
+            compile_to_dvc=True,
+        )
+        if status.errors:
+            raise_error("Pipeline checks failed: " + "; ".join(status.errors))
+        if status.failed_environment_checks:
+            raise_error(
+                "Pipeline environment checks failed for: "
+                + ", ".join(status.failed_environment_checks)
+            )
+        if status.is_stale:
+            raise_error(
+                "Pipeline is not up-to-date; out-of-date stages: "
+                + ", ".join(status.stale_stage_names)
+            )
     if publish:
         try:
             calkit.invenio.post(
@@ -245,8 +266,12 @@ def update_release(
         all_paths = calkit.releases.ls_files()
         typer.echo(f"Adding files to {zip_path}")
         with zipfile.ZipFile(zip_path, "w") as zipf:
-            for fpath in all_paths:
-                zipf.write(fpath)
+            calkit.releases.add_paths_to_zip(zipf, all_paths)
+        typer.echo("Checking project release archive")
+        try:
+            calkit.releases.check_project_release_archive(zip_path)
+        except Exception as e:
+            raise_error(str(e))
         try:
             files_in_record = [
                 entry["key"]

{calkit_python-0.35.5 → calkit_python-0.35.7}/calkit/dvc.py

@@ -9,6 +9,7 @@ import os
 from pathlib import Path
 from typing import Any
 
+import dvc.repo
 import git
 from dvc.utils.objects import cached_property
 from dvc_objects.fs.base import ObjectFileSystem
@@ -234,6 +235,12 @@ def run_dvc_cli(argv: list[str] | None = None) -> int:
     return dvc_main(argv)
 
 
+def get_dvc_repo(wdir: str | None = None) -> dvc.repo.Repo:
+    """Return a DVC repo with ``ck://`` scheme support registered."""
+    register_ck_scheme()
+    return dvc.repo.Repo(wdir)
+
+
 def run_dvc_command(argv: list[str], cwd: str | None = None) -> int:
     """Run a DVC command, optionally in a specific working directory.
 
@@ -367,14 +374,10 @@ def get_remotes(wdir: str | None = None) -> dict[str, str]:
     """Get a dictionary of DVC remotes, keyed by name, with URL as the
     value.
     """
-    import dvc.repo
     from dvc.exceptions import NotDvcRepoError
 
-    # Ensure DVC recognizes ck:// remotes when validating config.
-    register_ck_scheme()
-    repo_path = wdir or "."
     try:
-        repo = dvc.repo.Repo(repo_path)
+        repo = get_dvc_repo(wdir)
     except NotDvcRepoError:
         return {}
     try:
@@ -403,9 +406,7 @@ def list_files(wdir: str | None = None, recursive=True) -> list[dict]:
     """Return a list with all files in DVC, including their path and md5
     checksum.
     """
-    import dvc.repo
-
-    dvc_repo = dvc.repo.Repo(wdir)
+    dvc_repo = get_dvc_repo(wdir)
     return dvc_repo.ls(".", dvc_only=True, recursive=recursive)
 
 

calkit_python-0.35.7/calkit/git.py

@@ -0,0 +1,297 @@
+"""Git-related functionality."""
+
+from __future__ import annotations
+
+import os
+from os import PathLike
+from pathlib import Path
+
+import git
+
+
+def get_staged_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of staged files for the repo at ``path`` or the provided
+    repo.
+    """
+    if repo is None:
+        repo = git.Repo(path)
+    cmd = ["--staged", "--name-only"]
+    if path is not None:
+        cmd.append(path)
+    diff = repo.git.diff(cmd)
+    paths = diff.split("\n")
+    return [p for p in paths if p]
+
+
+def get_changed_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of files that have been changed but not staged."""
+    if repo is None:
+        repo = git.Repo(path)
+    return [
+        item.a_path
+        for item in repo.index.diff(None)
+        if item.a_path is not None
+    ]
+
+
+def get_untracked_files(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[str]:
+    """Get a list of untracked files."""
+    if repo is None:
+        repo = git.Repo(path)
+    return repo.untracked_files
+
+
+def get_staged_files_with_status(
+    path: str | None = None, repo: git.Repo | None = None
+) -> list[dict]:
+    if repo is None:
+        repo = git.Repo(path)
+    cmd = ["--staged", "--name-status"]
+    if path is not None:
+        cmd.append(path)
+    diff = repo.git.diff(cmd)
+    paths = diff.split("\n")
+    res = []
+    for pathi in paths:
+        # Make sure line is not empty, e.g., a trailing newline
+        if pathi:
+            status, p = pathi.split("\t")
+            res.append({"status": status, "path": p})
+    return res
+
+
+def ls_files(repo: git.Repo, *args, **kwargs) -> list[str]:
+    """Get a list of all files tracked by git."""
+    output = repo.git.ls_files(*args, **kwargs)
+    return [f for f in output.split("\n") if f]
+
+
+def _resolve_repo_and_ignore_path(
+    repo: git.Repo, path: str | PathLike
+) -> tuple[git.Repo, str]:
+    """Resolve which repo should own ignore rules for ``path``."""
+    # Normalize target path to absolute from the current repo root.
+    repo_root = Path(repo.working_dir).resolve()
+    path_obj = Path(path)
+    if path_obj.is_absolute():
+        abs_path = path_obj.resolve()
+    else:
+        abs_path = (repo_root / path_obj).resolve()
+    # If the path is inside a submodule, use that repo and relative path.
+    for submodule in repo.submodules:
+        submodule_root = (repo_root / submodule.path).resolve()
+        if abs_path == submodule_root:
+            continue
+        if abs_path.is_relative_to(submodule_root):
+            sub_repo = submodule.module()
+            rel_path = abs_path.relative_to(submodule_root).as_posix()
+            return sub_repo, rel_path
+    # Fall back to a repo-relative path when possible.
+    try:
+        rel_path = abs_path.relative_to(repo_root).as_posix()
+    except ValueError:
+        rel_path = path_obj.as_posix()
+    return repo, rel_path
+
+
+def _get_matching_gitignore_details(
+    repo: git.Repo, path: str
+) -> tuple[Path | None, str | None]:
+    """Return the repo-local gitignore file and pattern matching ``path``."""
+    try:
+        check_ignore = repo.git.check_ignore("-v", "--", path)
+    except git.GitCommandError:
+        return None, None
+    line = check_ignore.splitlines()[0]
+    try:
+        source_info, _ = line.split("\t", 1)
+        source_path, _, pattern = source_info.rsplit(":", 2)
+    except ValueError:
+        return None, None
+    if not source_path.endswith(".gitignore"):
+        return None, pattern
+    gitignore_path = (Path(repo.working_dir) / source_path).resolve()
+    try:
+        gitignore_path.relative_to(Path(repo.working_dir).resolve())
+    except ValueError:
+        return None, pattern
+    return gitignore_path, pattern
+
+
+def ensure_path_is_ignored(
+    repo: git.Repo, path: str | PathLike
+) -> None | bool:
+    """Ensure that the given path is ignored by Git.
+
+    Returns True if ``.gitignore`` was modified.
+    """
+    # Resolve whether the ignore rule belongs to this repo or a submodule.
+    target_repo, target_path = _resolve_repo_and_ignore_path(repo, path)
+    # No-op if Git already ignores this path.
+    if target_repo.ignored(target_path):
+        return
+    # Read gitignore first to check if the path is already ignored
+    # If not, we don't want to add a line for it since it was added
+    # TODO: Add an option to remove cached (`git rm --cached`)
+    gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+    if os.path.isfile(gitignore_path):
+        with open(gitignore_path) as f:
+            gitignore_txt = f.read()
+        lines = gitignore_txt.splitlines()
+        if target_path in lines:
+            return
+    with open(gitignore_path, "a") as f:
+        if (
+            os.path.isfile(gitignore_path)
+            and os.path.getsize(gitignore_path) > 0
+        ):
+            f.write("\n")
+        f.write(f"{target_path}\n")
+        return True
+
+
+def ensure_path_is_not_ignored(
+    repo: git.Repo, path: str | PathLike
+) -> None | bool:
+    """Ensure a path is not ignored by Git."""
+    # Resolve whether the unignore rule belongs to this repo or a submodule.
+    target_repo, target_path = _resolve_repo_and_ignore_path(repo, path)
+    # No-op if Git does not ignore this path.
+    if not target_repo.ignored(target_path):
+        return
+    matching_gitignore_path, matched_pattern = _get_matching_gitignore_details(
+        target_repo, target_path
+    )
+    if matching_gitignore_path is not None:
+        gitignore_path = matching_gitignore_path.as_posix()
+        path_for_gitignore = (
+            (Path(target_repo.working_dir) / target_path)
+            .resolve()
+            .relative_to(matching_gitignore_path.parent.resolve())
+            .as_posix()
+        )
+    else:
+        gitignore_path = os.path.join(target_repo.working_dir, ".gitignore")
+        path_for_gitignore = target_path
+    if not os.path.isfile(gitignore_path):
+        with open(gitignore_path, "w") as f:
+            f.write(f"!{path_for_gitignore}\n")
+        return True
+    with open(gitignore_path) as f:
+        gitignore_txt = f.read()
+    lines = gitignore_txt.splitlines()
+    direct_rule_variants = [path_for_gitignore, f"/{path_for_gitignore}"]
+    if matched_pattern is not None and matched_pattern.startswith("/"):
+        no_ignore_line = f"!/{path_for_gitignore}"
+    else:
+        no_ignore_line = f"!{path_for_gitignore}"
+    path_parts = Path(path_for_gitignore).parts
+
+    def ancestor_requires_recursive_unignore() -> bool:
+        """Return True if any ancestor-level ignore rule would block this path.
+
+        This includes explicit directory ignores (e.g. 'dir/' or '/dir/')
+        as well as ancestor-based glob patterns like 'dir/*' or '/dir/*',
+        i.e., any rule that would prevent reaching the nested path without
+        adding recursive unignore patterns.
+        """
+        for i in range(1, len(path_parts)):
+            ancestor = "/".join(path_parts[:i])
+            if (
+                ancestor in lines
+                or f"/{ancestor}" in lines
+                or f"{ancestor}/" in lines
+                or f"/{ancestor}/" in lines
+                or f"{ancestor}/*" in lines
+                or f"/{ancestor}/*" in lines
+            ):
+                return True
+        return False
+
+    if len(path_parts) == 1:
+        # Simple (non-nested) path: remove the direct ignore rule, or add a
+        # negation if the ignore comes from a glob or other pattern
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+        else:
+            # Remove any stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+    else:
+        # Nested path: only apply recursive un-ignore rules when an ancestor
+        # directory is explicitly ignored
+        # Otherwise, remove a direct ignore
+        # rule for this path or add a simple negation if needed
+        removed_direct_rule = False
+        direct_rule = next(
+            (rule for rule in direct_rule_variants if rule in lines), None
+        )
+        if direct_rule is not None:
+            lines.remove(direct_rule)
+            removed_direct_rule = True
+        if ancestor_requires_recursive_unignore():
+            # Git will not traverse into a directory excluded by a "dir/"
+            # pattern, so a bare "!dir/sub/file" negation has no effect.
+            # We need to:
+            #   1. Convert any "ancestor/" (or "ancestor") exclude to
+            #      "ancestor/*" so git traverses the directory while still
+            #      ignoring direct children by default.
+            #   2. Add "!ancestor/" rules for intermediate directories.
+            #   3. Add "ancestor/*" re-ignore rules for each intermediate dir.
+            #   4. Add "!target_path" for the specific file.
+            for i in range(1, len(path_parts)):
+                ancestor = "/".join(path_parts[:i])
+                reignore_glob = f"{ancestor}/*"
+                if f"{ancestor}/" in lines:
+                    idx = lines.index(f"{ancestor}/")
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}/" in lines:
+                    idx = lines.index(f"/{ancestor}/")
+                    lines[idx] = f"/{ancestor}/*"
+                elif ancestor in lines:
+                    idx = lines.index(ancestor)
+                    lines[idx] = reignore_glob
+                elif f"/{ancestor}" in lines:
+                    idx = lines.index(f"/{ancestor}")
+                    lines[idx] = f"/{ancestor}/*"
+                no_ignore_dir = f"!{ancestor}/"
+                anchored_no_ignore_dir = f"!/{ancestor}/"
+                # The first ancestor does not need an explicit un-ignore once
+                # converted to "ancestor/*". Deeper ancestors do.
+                if i > 1:
+                    # Remove stale entry and re-append so it takes precedence
+                    if no_ignore_dir in lines:
+                        lines.remove(no_ignore_dir)
+                    elif anchored_no_ignore_dir in lines:
+                        lines.remove(anchored_no_ignore_dir)
+                    lines.append(no_ignore_dir)
+                if (
+                    reignore_glob not in lines
+                    and f"/{ancestor}/*" not in lines
+                ):
+                    lines.append(reignore_glob)
+            # Remove stale negation and re-append at the end so it takes
+            # precedence over any later re-ignore rule
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+        elif not removed_direct_rule:
+            # The path may be ignored by a non-directory pattern (e.g., glob);
+            # remove stale negation and append at end so it takes precedence
+            if no_ignore_line in lines:
+                lines.remove(no_ignore_line)
+            lines.append(no_ignore_line)
+    with open(gitignore_path, "w") as f:
+        f.write(os.linesep.join(lines))
+    return True