Creating minimal parcel fixtures that reproduce topology bugs

def is_reproducible(features, op, attempts=3) -> bool:
    """The same input must fail the same way every time before shrinking begins."""
    errors = []
    for _ in range(attempts):
        try:
            op(features)
            return False               # it passed: not reproducible
        except Exception as exc:
            errors.append(f"{type(exc).__name__}: {exc}")
    return len(set(errors)) == 1       # identical failure each time

def shrink_features(features, op):
    """Delta-debugging on the feature list: repeatedly try to drop half, keeping any
    subset that still fails. Converges on a minimal failing set, which for overlay
    bugs is usually two or three parcels."""
    current = list(features)
    granularity = 2

    while len(current) >= 2:
        chunk = max(1, len(current) // granularity)
        reduced = False
        for start in range(0, len(current), chunk):
            candidate = current[:start] + current[start + chunk:]
            if not candidate:
                continue
            if still_fails(candidate, op):
                current = candidate
                granularity = max(granularity - 1, 2)
                reduced = True
                break
        if not reduced:
            if granularity >= len(current):
                break
            granularity = min(granularity * 2, len(current))

    return current


def still_fails(features, op) -> bool:
    try:
        op(features)
        return False
    except Exception:
        return True

from shapely.geometry import Polygon


def shrink_ring(polygon, op_on_single, min_vertices=4):
    """Drop vertices while the failure survives and the ring stays a closed polygon."""
    coords = list(polygon.exterior.coords)[:-1]          # drop the closing duplicate
    i = 0
    while len(coords) > min_vertices and i < len(coords):
        trial = coords[:i] + coords[i + 1:]
        candidate = Polygon(trial + [trial[0]])
        # A shrink that changes WHY it fails is not a shrink. Requiring the same
        # exception type keeps the bisection honest.
        if same_failure(op_on_single, candidate, polygon):
            coords = trial
        else:
            i += 1
    return Polygon(coords + [coords[0]])


def same_failure(op, candidate, original) -> bool:
    def kind(geom):
        try:
            op(geom)
            return None
        except Exception as exc:
            return type(exc).__name__
    return kind(candidate) is not None and kind(candidate) == kind(original)

from shapely import affinity


def humanise(geoms, op, grid=0.01):
    """Translate to the origin and snap, keeping the failure. Purely cosmetic, and
    it is what turns a fixture into something reviewable."""
    minx = min(g.bounds[0] for g in geoms)
    miny = min(g.bounds[1] for g in geoms)
    moved = [affinity.translate(g, -minx, -miny) for g in geoms]
    if not still_fails(moved, op):
        return geoms                                  # translation changed it: keep original

    snapped = [Polygon([(round(x / grid) * grid, round(y / grid) * grid)
                        for x, y in g.exterior.coords]) for g in moved]
    return snapped if still_fails(snapped, op) else moved

def emit_fixture(geoms, path, error, versions):
    lines = [
        '"""Minimal reproduction, shrunk from a 41 000-parcel county layer.',
        "",
        f"Failure: {error}",
        f"GEOS {versions['geos']}, shapely {versions['shapely']}.",
        "",
        "Shrunk from 41 216 features / 812 vertices to "
        f"{len(geoms)} features / {sum(len(g.exterior.coords) - 1 for g in geoms)} vertices.",
        '"""',
        "from shapely.geometry import Polygon", "",
        "FEATURES = [",
    ]
    for g in geoms:
        pts = ", ".join(f"({x:g}, {y:g})" for x, y in list(g.exterior.coords)[:-1])
        lines.append(f"    Polygon([{pts}]),")
    lines.append("]")
    path.write_text("\n".join(lines) + "\n")

def test_the_shrunken_fixture_still_fails():
    """The fixture's whole purpose. If this ever passes, the bug is fixed and the
    test below should be the one asserting the fix."""
    with pytest.raises(GEOSException, match="non-noded"):
        overlay(FEATURES)


def test_make_valid_repairs_it():
    """The fix, asserted against the same minimal input."""
    repaired = [make_valid(g) for g in FEATURES]
    result = overlay(repaired)
    assert result.is_valid
    assert abs(result.area - sum(g.area for g in FEATURES)) < 0.01


def test_shrinking_preserves_the_failure_kind():
    big = load_fixture("county_extract_subset.gpkg")
    small = shrink_features(big, overlay)
    assert len(small) < len(big)
    assert still_fails(small, overlay)
    with pytest.raises(GEOSException, match="non-noded"):
        overlay(small)


def test_shrinker_terminates_on_a_passing_input():
    ok = [box(0, 0, 10, 10), box(20, 20, 30, 30)]
    assert not is_reproducible(ok, overlay)