provenance-core 0.3.0__tar.gz

provenance_core-0.3.0/.gitignore

@@ -0,0 +1,45 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.DS_Store
+
+# adduce writes its report and the repro sidecar here
+.adduce/
+
+# Publisher PDFs for the prior-art dig. Kept locally so `citations verify` can resolve
+# quotations against them; not redistributable, and this repository is public.
+
+# coverage byproducts
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Internal review packets: simulated-referee rounds and self-critique.
+# Local only -- this repository may go public.
+REVIEW_PACKET*.md
+
+# Development corpus: the downloaded articles and shallow clones are rebuildable from
+# frame.json, but the measurements taken from them are not -- ignoring the whole directory
+# lost one 32-article run when the tree was tidied. Subdirectories only, as arxiv_corpus does.
+# documentation site (Docusaurus)
+website/node_modules/
+website/build/
+website/.docusaurus/
+
+# nbconvert output from verifying the demo notebook runs
+notebooks/executed.ipynb
+
+# jupyter lite build state
+.jupyterlite.doit.db
+
+# arXiv LaTeX sources fetched for testing, rebuildable from resolved.json
+
+# CORE-Bench capsules: ~39 MB each, rebuildable from core_train.json
+
+# CORE-Bench capsule metadata: 4.3 MB, fetched from siegelz/core-bench
+
+# Internal reviews are never tracked. They live in reproducible-science-internal-audits.
+docs/reviews/

provenance_core-0.3.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.5
+Name: provenance-core
+Version: 0.3.0
+Summary: Primitives shared by the reproducible-science tools: content digests and git references
+Project-URL: Changelog, https://github.com/elliottower/reproducible-science/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/elliottower/reproducible-science
+Project-URL: Issues, https://github.com/elliottower/reproducible-science/issues
+Project-URL: Source, https://github.com/elliottower/reproducible-science/tree/main/packages/provenance-core
+Author-email: Elliot Tower <elliot@elliottower.ai>
+License-Expression: MIT
+Keywords: digest,git,provenance,reproducibility,sha256
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# provenance-core
+
+[![pypi](https://img.shields.io/pypi/v/provenance-core)](https://pypi.org/project/provenance-core/)
+[![python](https://img.shields.io/pypi/pyversions/provenance-core)](https://pypi.org/project/provenance-core/)
+[![license](https://img.shields.io/pypi/l/provenance-core)](https://github.com/elliottower/reproducible-science/blob/main/LICENSE)
+[![docs](https://img.shields.io/badge/docs-live-blue)](https://elliottower.github.io/reproducible-science/)
+
+Content digests and git references, shared by the reproducible-science tools.
+
+Internal to [reproducible-science](https://github.com/elliottower/reproducible-science). Nothing installs it directly; the tools that need it depend on it.
+
+Two things lived in four copies each before this package existed: hashing a file or a string,
+and asking git a question. The copies had drifted — one hashed in 64 KB blocks and another in
+1 MB, one encoded a string implicitly and the others explicitly, and one reported a missing
+`git` binary as success.
+
+```python
+from provenance_core import sha256_of_file, sha256_of_text
+from provenance_core.gitref import commit, is_dirty, try_run
+```
+
+MIT licensed.

provenance_core-0.3.0/README.md

@@ -0,0 +1,22 @@
+# provenance-core
+
+[![pypi](https://img.shields.io/pypi/v/provenance-core)](https://pypi.org/project/provenance-core/)
+[![python](https://img.shields.io/pypi/pyversions/provenance-core)](https://pypi.org/project/provenance-core/)
+[![license](https://img.shields.io/pypi/l/provenance-core)](https://github.com/elliottower/reproducible-science/blob/main/LICENSE)
+[![docs](https://img.shields.io/badge/docs-live-blue)](https://elliottower.github.io/reproducible-science/)
+
+Content digests and git references, shared by the reproducible-science tools.
+
+Internal to [reproducible-science](https://github.com/elliottower/reproducible-science). Nothing installs it directly; the tools that need it depend on it.
+
+Two things lived in four copies each before this package existed: hashing a file or a string,
+and asking git a question. The copies had drifted — one hashed in 64 KB blocks and another in
+1 MB, one encoded a string implicitly and the others explicitly, and one reported a missing
+`git` binary as success.
+
+```python
+from provenance_core import sha256_of_file, sha256_of_text
+from provenance_core.gitref import commit, is_dirty, try_run
+```
+
+MIT licensed.

provenance_core-0.3.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+build-backend = "hatchling.build"
+requires = [ "hatchling" ]
+
+[project]
+name = "provenance-core"
+version = "0.3.0"
+description = "Primitives shared by the reproducible-science tools: content digests and git references"
+readme = "README.md"
+keywords = [ "digest", "git", "provenance", "reproducibility", "sha256" ]
+license = "MIT"
+authors = [ { name = "Elliot Tower", email = "elliot@elliottower.ai" } ]
+requires-python = ">=3.11"
+classifiers = [
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Scientific/Engineering",
+]
+dependencies = [  ]
+urls.Changelog = "https://github.com/elliottower/reproducible-science/blob/main/CHANGELOG.md"
+urls.Homepage = "https://github.com/elliottower/reproducible-science"
+urls.Issues = "https://github.com/elliottower/reproducible-science/issues"
+urls.Source = "https://github.com/elliottower/reproducible-science/tree/main/packages/provenance-core"
+
+[tool.ruff]
+lint.isort.known-first-party = [ "provenance_core" ]

provenance_core-0.3.0/src/provenance_core/__init__.py

@@ -0,0 +1,23 @@
+"""Primitives shared by the reproducible-science tools.
+
+Digests and git references lived in four copies each, drifting quietly. This package is the
+one implementation, published only because the tools that need it are published separately
+and a workspace path does not survive into a wheel.
+"""
+
+from __future__ import annotations
+
+from .digests import ZERO, sha256_of_file, sha256_of_text
+from .gitref import GitError, at_commit, commit, is_dirty, run, try_run
+
+__all__ = [
+    "ZERO",
+    "GitError",
+    "at_commit",
+    "commit",
+    "is_dirty",
+    "run",
+    "sha256_of_file",
+    "sha256_of_text",
+    "try_run",
+]

provenance_core-0.3.0/src/provenance_core/digests.py

@@ -0,0 +1,42 @@
+"""Content addresses: hashing a file, and hashing a string.
+
+Four packages hashed independently before this module existed, and the copies had drifted.
+Two read the file in 1 MB blocks and one in 64 KB; one encoded a string with a bare
+`.encode()` and the others named UTF-8 explicitly. Neither difference changed a digest on the
+machines this ran on, which is what made them survive: a divergence that produces the same
+answer today is the kind that produces a different one later, on a platform whose default
+encoding is not UTF-8, and then two tools disagree about whether a file is the pinned one.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import pathlib
+
+#: The prev_hash of a chain's first entry: a digest that addresses nothing.
+ZERO = "0" * 64
+
+#: Read size. Large enough that hashing a PDF is not dominated by syscalls, small enough that
+#: a multi-gigabyte artifact does not have to fit in memory.
+_BLOCK = 1 << 20
+
+
+def sha256_of_file(path: pathlib.Path) -> str:
+    """Hash of a file on disk, streamed so a large artifact is never held in memory."""
+    h = hashlib.sha256()
+    with pathlib.Path(path).open("rb") as fh:
+        for block in iter(lambda: fh.read(_BLOCK), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def sha256_of_text(text: str) -> str:
+    """Hash of a string, encoded as UTF-8.
+
+    The encoding is named rather than left to `str.encode()`'s default, because a digest that
+    depends on a platform default is not a content address.
+    """
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+__all__ = ["ZERO", "sha256_of_file", "sha256_of_text"]

provenance_core-0.3.0/src/provenance_core/gitref.py

@@ -0,0 +1,154 @@
+"""Asking git a question, with one policy for what a failure means.
+
+Three copies of this existed and disagreed about failure. One returned `None`, one raised,
+and one returned the empty string -- which made a missing `git` binary, a locked index and a
+directory outside a repository all indistinguishable from success. A freeze recorded a
+commit-shaped string in place of a commit because of it.
+
+The disagreement was not arbitrary: a provenance record wants "unknown" and a fetch wants an
+error. Both are offered, so a caller chooses deliberately rather than inheriting whichever
+policy its copy happened to have.
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import subprocess
+
+#: Long enough for a fetch over a slow link, short enough that a hung command is not forever.
+DEFAULT_TIMEOUT = 30
+
+#: Environment variables that decide which repository git acts on, overriding `cwd`.
+#:
+#: Git resolves its repository from the environment first and the working directory second, so
+#: `cwd` alone does not name a repository. Every git hook exports `GIT_DIR`, and `pre-commit`
+#: exports `GIT_INDEX_FILE` while it stashes, which is enough to make `of_tree(path)` report the
+#: commit and dirty state of whatever repository invoked it rather than of `path`.
+#:
+#: Only the redirecting variables are dropped. `GIT_SSH_COMMAND`, `GIT_CONFIG_GLOBAL`,
+#: `GIT_AUTHOR_DATE` and the rest configure how git behaves once it knows where it is, and a
+#: caller that set them meant them.
+REDIRECTS = (
+    "GIT_DIR",
+    "GIT_WORK_TREE",
+    "GIT_COMMON_DIR",
+    "GIT_INDEX_FILE",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_NAMESPACE",
+    "GIT_PREFIX",
+    "GIT_CEILING_DIRECTORIES",
+    "GIT_DISCOVERY_ACROSS_FILESYSTEM",
+)
+
+
+def clean_env(**overrides: str) -> dict[str, str]:
+    """This process's environment with `REDIRECTS` dropped, plus any overrides.
+
+    Exported because callers that run git themselves need the same guarantee and would
+    otherwise each keep their own copy of the list. `GIT_COMMITTER_DATE` and the other
+    variables that configure git rather than relocate it survive, so a caller can still set
+    them: `clean_env(GIT_COMMITTER_DATE=when)`.
+    """
+    return {**{k: v for k, v in os.environ.items() if k not in REDIRECTS}, **overrides}
+
+
+def _env(cwd: pathlib.Path | None) -> dict[str, str] | None:
+    """The environment to run git in, given the directory the caller named.
+
+    Naming a directory means that directory. Where `cwd` is None the caller has said "wherever
+    we are", and an inherited `GIT_DIR` is then the answer rather than an override, so the
+    environment is passed through untouched.
+    """
+    return None if cwd is None else clean_env()
+
+
+class GitError(Exception):
+    """Git could not answer: absent, timed out, or the command failed."""
+
+    def __init__(self, args: tuple[str, ...], detail: str) -> None:
+        self.args_run = args
+        self.detail = detail
+        super().__init__(f"git {' '.join(args)}: {detail}")
+
+
+def run(
+    *args: str, cwd: pathlib.Path | None = None, timeout: int = DEFAULT_TIMEOUT
+) -> str:
+    """Stdout of one git command. Raises `GitError` on any failure.
+
+    Use where a failure is a fact the caller must handle. Reporting it as an empty string is
+    how a repository with no commit reads as one with a commit.
+    """
+    try:
+        proc = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            env=_env(cwd),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,  # the return code is inspected below and becomes a typed error
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError) as e:
+        raise GitError(args, str(e)) from e
+    if proc.returncode != 0:
+        raise GitError(
+            args, (proc.stderr or "").strip()[:200] or f"exit {proc.returncode}"
+        )
+    return proc.stdout.strip()
+
+
+def try_run(
+    *args: str, cwd: pathlib.Path | None = None, timeout: int = DEFAULT_TIMEOUT
+):
+    """Stdout, or None when git could not answer.
+
+    Use where absence is a legitimate result -- a provenance record for a directory that is
+    not a repository is empty, not an error.
+    """
+    try:
+        return run(*args, cwd=cwd, timeout=timeout)
+    except GitError:
+        return None
+
+
+def commit(cwd: pathlib.Path | None = None) -> str | None:
+    """The full SHA of HEAD, or None where there is no commit to name."""
+    return try_run("rev-parse", "HEAD", cwd=cwd)
+
+
+def is_dirty(cwd: pathlib.Path | None = None) -> bool:
+    """Whether the working tree has uncommitted changes.
+
+    A tree at the right commit with edited files holds bytes that exist only on that machine,
+    so a result verified against it is not one anybody else can reproduce. An unreadable tree
+    answers False: not knowing is not the same as knowing it is dirty, and the caller that
+    cares has already checked that git can answer.
+    """
+    return bool(try_run("status", "--porcelain", cwd=cwd))
+
+
+def at_commit(cwd: pathlib.Path, expected: str) -> bool:
+    """Whether HEAD is exactly the commit named.
+
+    Exact, not a prefix match: an abbreviated SHA that happens to prefix another commit would
+    silently accept the wrong revision. A tree git cannot read answers False rather than
+    matching an empty expectation.
+    """
+    head = commit(cwd)
+    return head is not None and head == expected
+
+
+__all__ = [
+    "DEFAULT_TIMEOUT",
+    "REDIRECTS",
+    "GitError",
+    "at_commit",
+    "clean_env",
+    "commit",
+    "is_dirty",
+    "run",
+    "try_run",
+]

provenance_core-0.3.0/tests/test_primitives.py

@@ -0,0 +1,248 @@
+"""What the four copies disagreed about, asserted once."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import pathlib
+import subprocess
+
+import pytest
+
+from provenance_core import gitref
+from provenance_core.digests import ZERO, sha256_of_file, sha256_of_text
+
+
+def test_a_file_and_its_bytes_hash_alike(tmp_path):
+    p = tmp_path / "a.bin"
+    body = b"the measured angle matches the Haar expectation\n"
+    p.write_bytes(body)
+    assert sha256_of_file(p) == hashlib.sha256(body).hexdigest()
+
+
+def test_a_file_larger_than_one_block_hashes_correctly(tmp_path):
+    # The copies read in 1 MB and 64 KB blocks. Both are right only if the loop is right.
+    p = tmp_path / "big.bin"
+    body = bytes(range(256)) * 20_000  # ~5 MB, several blocks
+    p.write_bytes(body)
+    assert sha256_of_file(p) == hashlib.sha256(body).hexdigest()
+
+
+def test_text_is_hashed_as_utf8_whatever_the_platform_default(tmp_path):
+    # One copy used a bare `.encode()`. A digest that depends on a platform default is not a
+    # content address.
+    text = "ångström — naïve — 日本語"
+    assert sha256_of_text(text) == hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def test_the_zero_digest_is_a_sha256_shaped_string_addressing_nothing():
+    assert len(ZERO) == 64 and set(ZERO) == {"0"}
+
+
+# -- git: one policy per caller, chosen rather than inherited --------------------------------
+
+
+def git(*args, cwd):
+    """Run git against `cwd` and nowhere else.
+
+    `cwd` does not decide which repository git acts on: `GIT_INDEX_FILE`, `GIT_DIR` and
+    `GIT_WORK_TREE` outrank it. Pre-commit sets `GIT_INDEX_FILE` while it stashes, so a test
+    inheriting the environment stages into the *outer* worktree's index, and a commit against
+    that index with one file staged leaves every other tracked file staged as deleted. That is
+    a wrecked checkout produced by a passing test, and under `pytest -n auto` the workers race
+    on the same index. Dropping every `GIT_*` variable is what makes `cwd` mean what it reads
+    as meaning.
+    """
+    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+    return subprocess.run(
+        args, cwd=cwd, env=env, check=True, capture_output=True, text=True
+    )
+
+
+@pytest.fixture
+def repo(tmp_path):
+    git("git", "init", "-q", cwd=tmp_path)
+    (tmp_path / "f.txt").write_text("one\n")
+    git("git", "add", "f.txt", cwd=tmp_path)
+    git(
+        "git",
+        "-c",
+        "user.email=t@t",
+        "-c",
+        "user.name=t",
+        "commit",
+        "-q",
+        "-m",
+        "c",
+        cwd=tmp_path,
+    )
+    return tmp_path
+
+
+def test_run_raises_where_try_run_returns_none(tmp_path):
+    """The distinction the three copies disagreed about, in one assertion.
+
+    A directory that is not a repository is a fact a provenance record reports as unknown and
+    a fetch reports as an error. Returning "" for it, as one copy did, made a repository with
+    no commit indistinguishable from one with a commit.
+    """
+    with pytest.raises(gitref.GitError):
+        gitref.run("rev-parse", "HEAD", cwd=tmp_path)
+    assert gitref.try_run("rev-parse", "HEAD", cwd=tmp_path) is None
+    assert gitref.commit(tmp_path) is None
+
+
+def test_commit_names_head(repo):
+    head = git("git", "rev-parse", "HEAD", cwd=repo).stdout.strip()
+    assert gitref.commit(repo) == head
+    assert gitref.at_commit(repo, head)
+
+
+def test_at_commit_is_exact_and_refuses_a_prefix(repo):
+    head = gitref.commit(repo)
+    assert head is not None
+    assert not gitref.at_commit(repo, head[:8]), (
+        "an abbreviation could prefix another commit"
+    )
+    assert not gitref.at_commit(repo, "")
+    assert not gitref.at_commit(pathlib.Path(repo) / "nope", head)
+
+
+def test_a_directory_that_is_not_a_repository_is_not_at_any_commit(tmp_path):
+    assert not gitref.at_commit(tmp_path, "0" * 40)
+    assert not gitref.at_commit(tmp_path, "")
+
+
+def test_dirty_tracks_the_working_tree(repo):
+    assert not gitref.is_dirty(repo)
+    (repo / "f.txt").write_text("two\n")
+    assert gitref.is_dirty(repo)
+
+
+def test_a_missing_git_binary_is_an_error_not_an_empty_answer(repo, monkeypatch):
+    def absent(*a, **kw):
+        raise FileNotFoundError("git")
+
+    monkeypatch.setattr(gitref.subprocess, "run", absent)
+    with pytest.raises(gitref.GitError) as e:
+        gitref.run("rev-parse", "HEAD", cwd=repo)
+    assert "git" in str(e.value)
+    assert gitref.try_run("rev-parse", "HEAD", cwd=repo) is None
+
+
+def test_git_acts_on_cwd_even_when_the_environment_names_another_index(tmp_path):
+    outer, inner = tmp_path / "outer", tmp_path / "inner"
+    for d in (outer, inner):
+        d.mkdir()
+        git("git", "init", "-q", cwd=d)
+    (outer / "kept.txt").write_text("x\n")
+    git("git", "add", "kept.txt", cwd=outer)
+    git(
+        "git",
+        "-c",
+        "user.email=t@t",
+        "-c",
+        "user.name=t",
+        "commit",
+        "-q",
+        "-m",
+        "c",
+        cwd=outer,
+    )
+    (inner / "f.txt").write_text("one\n")
+
+    poisoned = dict(os.environ, GIT_INDEX_FILE=str(outer / ".git" / "index"))
+    subprocess.run(["git", "add", "f.txt"], cwd=inner, env=poisoned, check=False)
+    assert git("git", "status", "--short", cwd=outer).stdout.strip(), (
+        "the inherited environment should have staged into the outer index; if this is empty "
+        "the demonstration no longer demonstrates anything and the test below proves nothing"
+    )
+
+    git("git", "reset", "-q", "--hard", cwd=outer)
+    git("git", "add", "f.txt", cwd=inner)
+    assert git("git", "status", "--short", cwd=outer).stdout.strip() == ""
+
+
+# -- cwd names the repository, and outranks an environment that names another ------------------
+
+
+@pytest.fixture
+def elsewhere(tmp_path_factory):
+    """A second repository with one commit, to be named by the environment and not obeyed."""
+    d = tmp_path_factory.mktemp("elsewhere")
+    git("git", "init", "-q", cwd=d)
+    (d / "other.txt").write_text("other\n")
+    git("git", "add", "other.txt", cwd=d)
+    git(
+        "git",
+        "-c",
+        "user.email=t@t",
+        "-c",
+        "user.name=t",
+        "commit",
+        "-q",
+        "-m",
+        "o",
+        cwd=d,
+    )
+    return d
+
+
+@pytest.mark.parametrize("var", ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"])
+def test_the_commit_named_is_the_one_in_cwd_not_the_one_in_the_environment(
+    repo, elsewhere, monkeypatch, var
+):
+    # Every git hook exports GIT_DIR, and pre-commit exports GIT_INDEX_FILE while it stashes.
+    # Under either, `of_tree(path)` used to record the invoking repository's commit as the
+    # provenance of `path` -- a provenance record naming a repository nobody asked about.
+    target = elsewhere / ".git" if var != "GIT_WORK_TREE" else elsewhere
+    monkeypatch.setenv(
+        var, str(target / "index" if var == "GIT_INDEX_FILE" else target)
+    )
+    mine = git("git", "rev-parse", "HEAD", cwd=repo).stdout.strip()
+    theirs = git("git", "rev-parse", "HEAD", cwd=elsewhere).stdout.strip()
+    assert mine != theirs
+    assert gitref.commit(repo) == mine
+
+
+def test_a_directory_outside_any_repository_is_still_outside_one(
+    tmp_path, elsewhere, monkeypatch
+):
+    monkeypatch.setenv("GIT_DIR", str(elsewhere / ".git"))
+    plain = tmp_path / "plain"
+    plain.mkdir()
+    assert gitref.commit(plain) is None
+    with pytest.raises(gitref.GitError):
+        gitref.run("rev-parse", "HEAD", cwd=plain)
+
+
+def test_a_clean_tree_reads_clean_while_the_environment_names_a_dirty_one(
+    repo, elsewhere, monkeypatch
+):
+    (elsewhere / "scratch.txt").write_text("uncommitted\n")
+    monkeypatch.setenv("GIT_DIR", str(elsewhere / ".git"))
+    monkeypatch.setenv("GIT_WORK_TREE", str(elsewhere))
+    assert gitref.is_dirty(elsewhere)
+    assert not gitref.is_dirty(repo)
+
+
+def test_a_caller_that_names_no_directory_still_inherits_the_environment(
+    elsewhere, monkeypatch
+):
+    # The other half of the rule. `cwd=None` means "wherever we are", so an inherited GIT_DIR
+    # is the answer rather than an override, and dropping it would break a caller inside a hook
+    # that meant the hook's repository.
+    monkeypatch.setenv("GIT_DIR", str(elsewhere / ".git"))
+    monkeypatch.setenv("GIT_WORK_TREE", str(elsewhere))
+    theirs = git("git", "rev-parse", "HEAD", cwd=elsewhere).stdout.strip()
+    assert gitref.commit() == theirs
+
+
+def test_a_variable_that_configures_git_rather_than_relocating_it_survives(
+    repo, monkeypatch
+):
+    # The list is narrow on purpose: dropping every GIT_* would take GIT_SSH_COMMAND and the
+    # identity variables with it, which a caller that set them meant.
+    monkeypatch.setenv("GIT_AUTHOR_NAME", "Someone Named")
+    assert "GIT_AUTHOR_NAME" not in gitref.REDIRECTS
+    assert gitref.run("var", "GIT_AUTHOR_IDENT", cwd=repo).startswith("Someone Named")