[brettheap]

Lane: openreposhape-3 (openRepoShape-3)
Claim: #683 (comment)

Closes #683.

Re-measured on main de926142 (git 2.43.0)

The issue's two cases still hold. The standard is a bare clone of de926142 with uploadpack.allowFilter, and Atlas was scaffolded at bf7b19ba (de926142~30).

• Online. shape-doctor.py --root Atlas, run from a --no-local --filter=blob:none clone, answers COMPLIANT, SHAPE BEHIND (5 upstream-changed, 0 upstream-added) (exit 1).
  • The objects missing at the pin go from 1255 to 1250 (rev-list --objects --missing=print).
  • A trace2 log shows five lazy fetch origin ... --filter=blob:none --stdin. Their parents are git show bf7b19ba…:<source> for templates/assembly-root/scripts/validate-pins.py, validate-manifest.py, bootstrap.py, scripts/repo_shape.py and scripts/validate-repository-naming.py.
• Offline. The same clone with remote.origin.url leading nowhere answers DRIFTED (5 both) (exit 1). update-shape.py check --upstream <that clone> prints the same five both rows (exit 1).

Two claims of the issue's needed amending:

• remote.<name>.promisor = false is not the only key. git 2.43's promisor-remote.c also makes a remote a promisor when remote.<name>.partialclonefilter is set, whatever promisor says.
  • Measured on a blob:none clone: promisor = false plus the filter git's clone writes still fetched (missing 48 → 47).
  • promisor = false alone fetched nothing, and the read failed (exit 128).
  • So the old regexp was right for promisor = false only by accident: it never read the filter key.
• Upstream.resolve fetches too. rev-parse --verify <sha>^{commit}, prepare's first read of the pinned commit, lazily fetches a commit the clone lacks: 24 trace2 fetch events.
  • rev-list --objects --no-walk --missing=print <sha> exits 128 (bad object) on that commit, with no fetch.
  • So the check has to come before prepare, not only before the blob reads.

What changed and why

shape-doctor.py

• partial_clone_row (shape-doctor.py:4405). It is asked from check_shape_currency at :4522, after read_pin and before prepare.
  • Where partial_clone holds, objects_lacking (:4378) runs git rev-list --objects --no-walk --missing=print at the pinned commit and at HEAD. That command never fetches, and it runs before any ls-tree.
  • Where either commit lacks an object, or rev-list cannot list a commit (the clone does not hold it), the row is CANNOT ANSWER: detail.environment, exit 3, error: shape-doctor-partial-clone (:4402).
  • The detail holds pinned, standard, remote and lacking ({commit: count}).
  • Where nothing is missing (a partial clone whose pin names its own HEAD), the row answers as it does today.
• Whole tree, not the copies' paths.
  • --missing=print names a missing object by its id alone. Finding its path means reading the tree that holds it, which a tree:0 clone also lacks.
  • The paths the comparison reads are prepare's to define. A second list of them in the doctor would drift.
  • The cost: a partial clone pinned behind its HEAD is CANNOT ANSWER even where no copy changed. The NEXT ends that.
• promisor_remotes (:4019), with partial_clone (:3999) now bool(promisor_remotes(shape)). This is git's own reading of its config:
  • a remote whose promisor is true (git config --type=bool, so a bare promisor key counts);
  • a remote with a partialclonefilter;
  • the remote extensions.partialclone names, last, as git asks it.
• check_shape_currency (:4529). A prepare refusal of a read that failed (update-upstream-unreadable, see below) gets a why of its own and no NEXT.
  • The precedent row's fetch --all and its "does not carry the commit" would both be false there.
  • This branch is reached only from a clone that lacks objects with no promisor remote (promisor = false alone), or from a damaged one.
• as_the_standard_wrote_it (:4073) now catches Refusal beside OSError and ValueError, so a read Upstream.blob refuses is "not proved", as None was.
  • This is required, not optional: a side's pin naming a commit the checkout lacks now raises from files_at where it used to give None.
  • pin_restore itself is untouched.
• Module docstring (:27, :318). The doctor fetches nothing, and that is true again. A partial clone is now asked first, and exit 3 now names "a partial clone lacking what the comparison reads".

The NEXT, chosen by the precedent row's rule

The precedent row (shape-doctor.py:4548) gives a checkout short of the pin's commit git -C <shape> fetch --all: the command a person runs to put into THIS checkout what it lacks. Its why names the other way, a clone that has the commit. This row follows the same rule:

• NEXT: git -C <shape> fetch --refetch --no-filter <promisor remote>.
  • fetch --all would bring no blob, because a promisor remote's fetch keeps its partialclonefilter.
  • --refetch --no-filter measured: 1294 missing → 0, with the config left as it was.
  • Run as printed, the doctor run again gives the full clone's answer. That is measured and tested.
  • It names the remote because fetch --all --refetch --no-filter with two remotes passed neither option on (1294 → 1294).
• why: "fetch every object holds, then run the doctor again, or run it from a full clone of the standard".
• Not "none". A CANNOT ANSWER with a working one-line remedy should print it, as the precedent does.
• Not openRepoShape --doctor <root>.
  • It needs the package installed.
  • It answers against the package's stamped commit, not this checkout's HEAD.
  • From an editable install beside this clone, it runs this same doctor and gets this same row.
• --refetch needs git 2.36. On an older git the NEXT fails with an unknown option, and the why gives the full-clone way.

update-shape.py

• Upstream.blob (update-shape.py:393) reads with git cat-file blob <rev>:<path>.
  • That is the same <rev>:<path> and the same bytes as git show for every file, ./x included (measured).
  • Where the read fails, files_at(rev) (:427, one ls-tree -r -z --full-tree per revision, cached, only after a failed read) says whether rev lists a file at that exact path.
    • It does not: None, as before.
    • It does, or the listing itself fails: update-upstream-unreadable (:452, built by unreadable_upstream at :455), quoting git's exit and words.
  • So check and apply refuse in prepare, before any write, rather than reach _classify_row's pinned None (:766) and _row_verdict's both.
• open_upstream's docstring (:472) no longer says "NOTHING IS FETCHED" of a path. A partial clone's git fetches on a read; this tool fetches nothing into it; a failed fetch refuses.

Every caller of Upstream.blob, checked for changed behaviour:

• source_for (:664).
  • Absent candidates are still None, so the next candidate is tried.
  • A candidate that exists but cannot be read now refuses. It used to fall through to the next candidate, or to unmapped.
  • A candidate that is a directory is now None. git show used to return its tree listing as "bytes" with exit 0.
• _classify_row (:794-795).
  • Pinned or target read failed: refuses. It used to be both, or upstream-removed for the target.
  • Absent path: unchanged.
• upstream_copies (:941, MATERIALIZER). A failed read refuses. It used to give {}, which silently meant "no additions".
• find_additions (:1199). A failed read refuses. The addition used to be skipped silently.
• _accepted_in_the_pin (:5013, _finish_landing).
  • A failed read now refuses, before anything is pushed or opened.
  • It used to drop the path from the PR body's accepted list.
  • prepare read the same target in the same run, so this is reachable only through a race.
• shape-doctor.py's as_the_standard_wrote_it. Refusal → False, as above.

Tested

• New file tests/test_doctor_partial_clone.py (21 cases). The partial clone is built as tests/test_doctor_pin_restore_merges.py:702-743 builds one: uploadpack.allowFilter, FILE_PROTOCOL, --no-local over file://.
• "Fetched nothing" is asked of git: rev-list --objects --all --missing=print lists the same objects before and after the run, and lists at least one.
• A partial clone behind its pin (C2 checked out, root pinned at C1): CANNOT ANSWER, exit 3, shape-doctor-partial-clone, nothing fetched. Four cases: blob:none and tree:0, each with its remote reachable and out of reach.
• The row's detail and NEXT: lacking == {C1: 1}, remote == "origin", NEXT pasted argv git -C <clone> fetch --refetch --no-filter origin.
• The NEXT run as printed: the clone then lacks nothing, and the doctor answers COMPLIANT, SHAPE BEHIND (1 upstream-changed, 0 upstream-added).
• A partial clone pinned at its own HEAD (C1 checked out, C2's blob still missing): the same verdict as the full clone, with nothing fetched.
• HEAD is asked too: C1 complete, HEAD moved to C2 with no checkout gives lacking == {C2: 1}, with nothing fetched. A mutant that asks only the pinned commit fails it.
• promisor = false alone, remote reachable: the row is update-upstream-unreadable, NEXT None, exit 3, nothing fetched, no both.
• update-shape.py check against an unreachable partial clone (blob:none, tree:0): exit 2, REFUSED update-upstream-unreadable: <clone>, no both.
• partial_clone / promisor_remotes on a full --no-local clone, with config appended as bytes:
  • none → False;
  • [extensions]\n\tpartialclone = origin\n → True (Tracking: shape-doctor.py, reporting a repository's compliance #460 L14);
  • promisor = false → False;
  • promisor = true → True;
  • a bare promisor key → True;
  • a filter beside promisor = false → True;
  • the extension's remote listed last.
• Upstream.blob on a full clone: a file's bytes, None for an absent path, and None for a directory.
• Against main's code, the new file fails 17 of its first 20 cases. The 3 that pass are the ones main already got right: pinned at its own HEAD, and a present or absent blob.

Command, run in four groups at once (stub gh first on PATH, GH_TOKEN=bogus, empty GH_CONFIG_DIR):

/usr/bin/python3 -m pytest -q -p no:cacheprovider --basetemp=<scratch>/bt-w683-<group> -o tmp_path_retention_policy=failed <files>

Results:

• On ccdc2c94 (this commit on de926142):
  • tests/test_shape_doctor.py: 405 passed, 3 skipped in 798.00s (0:13:17).
  • tests/test_update_shape.py: 90 passed in 131.57s (0:02:11).
  • All 16 tests/test_update_shape_*.py: 576 passed, 3 skipped in 535.67s (0:08:55).
  • tests/test_doctor_partial_clone.py, tests/test_doctor_pin_restore_merges.py, tests/test_doctor_next_is_a_command.py, tests/test_repo_hygiene.py and tests/test_cli_reference.py, together: 192 passed in 417.68s (0:06:57).
• On 9f24bf31 (the same three files, byte for byte, rebased onto 30676c90): tests/test_doctor_partial_clone.py, tests/test_doctor_pin_restore_merges.py and tests/test_repo_hygiene.py, together: 114 passed in 209.30s (0:03:29).
• On 3027937d, the merge of main 66b230ed (shape-doctor.py: submodule_config and gitmodules_entry read a holder's .gitmodules through one git config -z --list, so a section name holding a space or a byte that is not UTF-8, or a url holding NEL or U+2028, gives the doctor the mount url git and make siblings use, under any locale (#668) #700, shape-doctor.py: a checkout whose own contracts/repository-naming.yaml does not load is CANNOT ANSWER, exit 3, for a project, where it read INVALID (naming), exit 1; any other naming exit 2 "refuses"; and the EXIT CODES list names an unfinished merge (#678) #701, validate-pins.py and shape-doctor.py: one leg's gitlink off its pin beside another leg's digest or workflow reference names the step that comes first, that gitlink put back by hand, and then the other leg's bump-leg.py line, so neither finding says "First clear that finding" over a finding no line can clear first (#677) #702, shape-doctor.py: the members row says, member by member, what make siblings does with the directory beside the holder, in its own word and in place's order, so it no longer says it places a member it leaves exactly as it is, and it spells every value it quotes, so an ESC or a CR in a url no longer reaches the terminal (#669, #673) #705 and others) into this branch. Its one conflict was shape-doctor.py's EXIT CODES list, exit 3: both sides added a cause, and both are kept in main's form.
  • tests/test_shape_doctor.py: 428 passed, 3 skipped, 1 xfailed in 461.66s (0:07:41).
  • tests/test_update_shape.py: 90 passed in 94.53s (0:01:34).
  • All 16 tests/test_update_shape_*.py: 576 passed, 3 skipped in 333.53s (0:05:33).
  • The new file, tests/test_doctor_pin_restore_merges.py, tests/test_doctor_next_is_a_command.py, tests/test_repo_hygiene.py and tests/test_cli_reference.py, together: 192 passed in 196.88s (0:03:16).
  • The shape-doctor.py anchors above are this head's.

Pinned copies

None. shape-doctor.py and update-shape.py are not copied into projects, so no project sees an upstream-changed row from this.

Docs

• The doctor's module docstring is updated as above.
• README.md, AGENTS.md and the handbook are not touched.
  • Their "fetches nothing" is true again.
  • README's exit-3 sentence ("…or a pin naming a commit this checkout does not carry (CANNOT ANSWER)") does not name the partial-clone case.
  • README and the handbook move together by section hash, and lane 2's README.md and the handbook: say that a source's own single-repository.yaml record arrives as leg: drop, that the adopted Makefile's CONTRACTS_DIR follows the spec leg's mount, and that a second setup run is refused at the plan, so the three sentences #566, #572 and #573 left false or incomplete are true of main (#606) #627 and lane 3's README, AGENTS.md, docs/cli.md and the handbook: pipx install openreposhape is the second way in and the first on native Windows, git-filter-repo is installed in install.sh's order and never with a bare pip install, and a first draft of the v1.1.0 release notes (#563) #630 are editing both. So that clause is left for lane 3's README turn rather than added here.
• docs/cli.md is unaffected: neither tool's --help changed.

Lands after / before

• shape-doctor.py: the pins row keeps its gate where update-shape.py check says REFUSAL AHEAD beside a merged-away row, so it no longer says that the apply check prints drops the row when that apply is refused, and the shape currency counts name every state check counts (#676) #751 (shape-doctor.py: the pins row says check's apply drops merged-away rows where check says REFUSAL AHEAD (a pinned copy kept as a link), and the shape currency counts leave out five of check's states #676, lane 3: the doctor's pins and shape currency rows) is stacked on this PR's head 3027937d and lands after it.
• shape-doctor.py: a conflicted shape pin's NEXT reads both sides' pins, so a copy conflicted beside it that only the side not taken has a files: row for is named in its why and left_for_a_person for a person to merge, and never taken (#687) #736 (shape-doctor.py pin_restore: a copy conflicted beside the shape pin that only the side NOT taken has a files: row for is neither taken nor named, so the conflicted pin's why and left_for_a_person say nothing of a file the merge still holds unmerged #687, lane 3, pin_restore) is open. This PR does not touch pin_restore, but its one-line except change in as_the_standard_wrote_it (shape-doctor.py:4073) sits in the function shape-doctor.py pin_restore: a copy conflicted beside the shape pin that only the side NOT taken has a files: row for is neither taken nor named, so the conflicted pin's why and left_for_a_person say nothing of a file the merge still holds unmerged #687's issue names. A textual conflict there, if any, is one line.

🤖 Generated with Claude Code

Summary by Sourcery

Handle partial and unreadable standard clones safely by refusing unverifiable comparisons instead of fetching or reporting false drift.

New Features:

• Detect partial standard clones before comparison and report when required objects are unavailable without fetching.
• Provide a corrective fetch command for partial clones that need the missing objects.

Bug Fixes:

• Prevent failed upstream reads from being interpreted as missing files or producing false both copy classifications.
• Correctly recognize promisor remotes using Git's partial-clone configuration semantics.

Enhancements:

• Make upstream file reads distinguish absent paths from unreadable files and refuse comparisons when reads fail.
• Ensure shape currency checks inspect both the pinned commit and the standard checkout's HEAD without fetching.

Documentation:

• Update shape-doctor guidance and exit-status documentation for partial-clone handling and unreadable upstream data.

Tests:

• Add coverage for partial clones, promisor-remote configuration variants, non-fetching checks, corrective fetches, and unreadable upstream reads.

[sourcery-ai]

Reviewer's Guide

Prevents partial-clone lazy fetches and misleading both verdicts by checking required objects before comparison, accurately recognizing Git promisor configuration, and refusing unreadable upstream files with actionable diagnostics; extensive tests cover the new behavior.

Sequence diagram for partial-clone shape currency check

sequenceDiagram
    participant Doctor as shape-doctor.py
    participant Git as Git repository
    participant Person as Person

    Doctor->>Git: config --type=bool --get-regexp
    Git-->>Doctor: promisor remotes
    Doctor->>Git: rev-list --objects --no-walk --missing=print pinned
    Git-->>Doctor: missing-object count
    Doctor->>Git: rev-list --objects --no-walk --missing=print HEAD
    Git-->>Doctor: missing-object count
    alt objects are missing
        Doctor-->>Person: CANNOT ANSWER
        Doctor-->>Person: git -C shape fetch --refetch --no-filter remote
    else nothing is missing
        Doctor->>Git: prepare and compare
        Git-->>Doctor: shape currency verdict
    end

Loading

Sequence diagram for unreadable upstream file refusal

sequenceDiagram
    participant Tool as update-shape.py
    participant Git as Upstream repository
    participant Person as Person

    Tool->>Git: cat-file blob rev:path
    alt read succeeds
        Git-->>Tool: file bytes
    else read fails
        Tool->>Git: ls-tree -r -z --full-tree rev
        alt path is absent
            Git-->>Tool: no file record
            Tool-->>Person: treat as absent
        else path exists or listing fails
            Git-->>Tool: file record or listing error
            Tool-->>Person: REFUSED update-upstream-unreadable
        end
    end

Loading

File-Level Changes

Change	Details	Files
Detect partial clones before comparison reads and report CANNOT ANSWER without fetching.	Identify promisor remotes using Git’s promisor, partial clone filter, and extension configuration semantics. Check all objects reachable from the pinned commit and HEAD with non-fetching rev-list calls. Add structured diagnostics and a remote-specific fetch --refetch --no-filter NEXT command. Keep the existing full-clone behavior when required objects are present.	shape-doctor.py tests/test_doctor_partial_clone.py
Distinguish missing upstream files from read failures and refuse unsafe comparisons.	Read upstream files with git cat-file blob and treat directories or absent paths as None. Cache ls-tree file listings to determine whether a failed read targets an existing file. Raise update-upstream-unreadable for existing files or failed tree listings. Propagate refusals through check, apply, source selection, additions, and accepted-copy handling instead of classifying failures as both or silently skipping them.	update-shape.py shape-doctor.py tests/test_doctor_partial_clone.py
Update documentation and regression coverage for non-fetching doctor behavior and failure handling.	Document that partial clones are checked before reads and that the doctor itself never fetches. Cover blob:none and tree:0 clones, reachable and unreachable remotes, promisor configuration variants, HEAD checks, remediation execution, and unreadable upstream refusals. Verify Upstream.blob behavior for files, absent paths, directories, and failed reads.	shape-doctor.py update-shape.py tests/test_doctor_partial_clone.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#683	Prevent the doctor’s shape-currency comparison from triggering lazy fetches in a partial clone; if required objects are missing, report CANNOT ANSWER with a person-run remedy, and otherwise preserve the comparison result.	✅
#683	Distinguish a genuinely absent upstream path from a failed read, so update-shape check/apply and the doctor refuse an unreadable comparison instead of classifying copies as “both.”	✅
#683	Recognize partial clones using Git’s relevant promisor configuration, including the extensions.partialclone alternative, and cover detection and no-fetch behavior with tests.	✅

Possibly linked issues

• shape-doctor.py: run from a partial clone of the standard, the shape currency row fetches what the clone lacks, and with its remote out of reach calls each copy the standard changed since the pin both, so a doctor that fetches nothing fetches, and offline says DRIFTED of copies nobody edited #683: The PR implements the issue’s requested pre-read availability check, CANNOT ANSWER result, and refusal of failed reads that could otherwise produce both verdicts.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sonarqubecloud]

Quality Gate passed

Issues
2 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[brettheap]

(lane openRepoShape-3, 2026-10-16T23:32:49Z) Lane 3's independent review of #742 at 3027937d (RV-f, ruling 8): READY. There is no MUST. Two SHOULDs and three NITs go to a v1.1.1 follow-up, and the docs NIT goes to lane 3's README turn. It lands once the Linux tests job at the head is green.

Measured on git 2.43.0. The standard was a bare copy, and Atlas was scaffolded 30 commits back with 5 copies changed since. Fetches were counted twice: by rev-list --missing=print before and after each run, and by trace2 fetch events.

run	main 66b230ed	head
doctor, blob:none, remote in reach	COMPLIANT, SHAPE BEHIND, exit 1; 5 lazy fetches	CANNOT ANSWER (… lacks 67 objects at the pinned commit …), exit 3; 0 fetches
doctor, blob:none, out of reach	DRIFTED (5 both); 5 failed fetches	exit 3; 0 fetches
doctor, tree:0, in reach and out of reach	6 and 11 fetch attempts	exit 3; 0 fetches
update-shape.py check, out of reach	5 both rows (blob:none), or git-failed (tree:0)	REFUSED update-upstream-unreadable, naming the path or the listing; no both

What else was checked

• The writer's two amended claims hold: a filter beside promisor = false still fetches, and rev-parse --verify <sha>^{commit} lazily fetches.
• No doctor path fetches: there are 23 git starts, and none is a fetch.
• A full clone gives --json identical to main's on five roots.
• The NEXT, run as printed, gives the full clone's exact answer with one remote, with blob:none and with tree:0.
• Upstream.blob never refuses a correct full-clone read. That covers a file, a symlink, a spaced name, a non-UTF-8 name, a directory, a gitlink and an absent path. All 666 update-shape tests pass.
• The merge resolution in 3027937d keeps both sides' EXIT CODES lines.

Mutants: ten of eleven are killed. The survivor:

• M9: a commit the clone lacks entirely counted as complete. It survives all 21 tests, and on a --single-branch blob:none clone it makes the doctor fetch 6 times. That is S1.

SHOULD, to the v1.1.1 follow-up

• S1: add a test where the partial clone lacks the pinned commit, so objects_lacking returns None (shape-doctor.py:4448-4451). Assert exit 3 and lacking == {C1: None}.

• S2: the NEXT names remotes[0] (:4462). It loops in two cases:

  • two promisor remotes with the pin only on the second;
  • a --single-branch partial clone whose pin is on another branch.

  Pick the remote whose tracking refs contain the commit (for-each-ref --contains, which does not fetch), and say in the why when the commit is not in the clone at all. The full-clone precedent row has the same single-branch weakness.

NIT

• N1: with tree:0, "lacks 1 object" should say "at least".
• N2: --refetch needs git 2.36.
• N3: optionally set GIT_NO_LAZY_FETCH=1 too. This git honours it, contrary to shape-doctor.py: run from a partial clone of the standard, the shape currency row fetches what the clone lacks, and with its remote out of reach calls each copy the standard changed since the pin both, so a doctor that fetches nothing fetches, and offline says DRIFTED of copies nobody edited #683's text.
• N4: the README and handbook exit-3 lists leave out this case. That goes to lane 3's README turn.

Tests at the head (stub gh):

• test_shape_doctor.py: 428 passed, 3 skipped, 1 xfailed;
• the five targeted suites: 192 passed;
• all 18 update-shape suites: 666 passed, 3 skipped;
• the new file over main's code: 18 failed;
• with shape-doctor.py: a conflicted shape pin's NEXT reads both sides' pins, so a copy conflicted beside it that only the side not taken has a files: row for is named in its why and left_for_a_person for a person to merge, and never taken (#687) #736: 41 passed.

Merges: clean with #734, #736, #737 and #740.

Lane: openreposhape-3 (openRepoShape-3)

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 23 hours and 42 minutes by commenting @sourcery-ai review. Upgrade to get a review now.