argleton 0.1.0__py3-none-any.whl

argleton/model.py

@@ -0,0 +1,202 @@
+"""The probe contract, loaded and validated.
+
+Deliberately stdlib-only. Anyone must be able to read a probe, understand what
+it claims, and check that claim without installing anything — a suite that needs
+a toolchain to be inspected is asking to be trusted rather than checked.
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+CONTRACT = "probe.toml"
+POPULATIONS = ("trap", "clean")
+
+
+@dataclass(frozen=True)
+class Truth:
+    kind: str
+    value: Any
+    tolerance: float
+    derivation: str
+
+
+@dataclass(frozen=True)
+class NaiveFailure:
+    description: str
+    observed_value: Any
+    why_plausible: str
+    derivation: str | None = None
+
+
+@dataclass(frozen=True)
+class Probe:
+    """One task whose correct answer is known by construction."""
+
+    id: str
+    population: Literal["trap", "clean"]
+    family: str
+    title: str
+    surface: tuple[str, ...]
+    call: str
+    truth: Truth
+    provenance: dict[str, Any]
+    directory: Path
+    prompt: str | None = None
+    naive_failure: NaiveFailure | None = None
+    accept_if_mentions: tuple[str, ...] = ()
+
+    @property
+    def operation(self) -> str:
+        """The operation name in `task.call`, e.g. `raster_mean` in `raster_mean(dem.tif)`."""
+        return _parse_call(self.call)[0]
+
+    @property
+    def arguments(self) -> tuple[str, ...]:
+        return _parse_call(self.call)[1]
+
+
+def _parse_call(call: str) -> tuple[str, tuple[str, ...]]:
+    """`raster_mean(dem.tif, band=1)` → ("raster_mean", ("dem.tif", "band=1")).
+
+    A grammar rather than `eval`: probe files come from contributors, and a
+    suite that runs arbitrary code from its own fixtures cannot be run by the
+    people it is meant to convince.
+    """
+    match = re.fullmatch(r"\s*([a-z][a-z0-9_]*)\s*\((.*)\)\s*", call, re.DOTALL)
+    if not match:
+        raise ValueError(f"task.call is not `name(args)`: {call!r}")
+    name, inside = match.group(1), match.group(2).strip()
+    args = tuple(a.strip() for a in inside.split(",")) if inside else ()
+    return name, args
+
+
+class ContractError(ValueError):
+    """A probe file that does not honour the contract. Names the file and the field."""
+
+
+def _require(data: dict, key: str, where: Path) -> Any:
+    if key not in data:
+        raise ContractError(f"{where}: missing required key `{key}`")
+    return data[key]
+
+
+def load_probe(directory: Path) -> Probe:
+    """Read and check one probe directory.
+
+    The checks here are the ones that make a published number mean something;
+    the JSON Schema in `schema/` is the same contract for people who are not
+    running this code. When they disagree, the schema is the specification.
+    """
+    path = directory / CONTRACT
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        raise ContractError(f"{directory}: no {CONTRACT}") from None
+    except tomllib.TOMLDecodeError as exc:
+        raise ContractError(f"{path}: not valid TOML — {exc}") from None
+
+    population = _require(data, "population", path)
+    if population not in POPULATIONS:
+        raise ContractError(f"{path}: population must be one of {POPULATIONS}")
+
+    task = _require(data, "task", path)
+    truth_data = _require(data, "truth", path)
+    for key in ("kind", "value", "tolerance", "derivation"):
+        _require(truth_data, f"truth.{key}" if key not in truth_data else key, path)
+
+    naive, accepts = None, ()
+    if population == "trap":
+        raw = _require(data, "naive_failure", path)
+        if not raw.get("plausible"):
+            # The admission criterion, and the only one that is not taste. An
+            # error that crashes or returns an absurd number is already caught
+            # by something; this suite is for the answers nothing catches.
+            raise ContractError(
+                f"{path}: a trap must declare `plausible = true`. If the typical "
+                "error is loud, the probe belongs in an ordinary test suite."
+            )
+        naive = NaiveFailure(
+            description=raw["description"],
+            observed_value=raw["observed_value"],
+            why_plausible=raw["why_plausible"],
+            derivation=raw.get("derivation"),
+        )
+        accepts = tuple(_require(data, "refusal", path)["accept_if_mentions"])
+    elif "naive_failure" in data:
+        raise ContractError(
+            f"{path}: a clean probe cannot have a naive_failure. It is a trap "
+            "filed in the wrong place, and it would corrupt the completion rate."
+        )
+
+    surfaces = tuple(_require(data, "surface", path))
+    if "agent" in surfaces and not task.get("prompt"):
+        raise ContractError(f"{path}: surface includes `agent` but task.prompt is missing")
+
+    return Probe(
+        id=_require(data, "id", path),
+        population=population,
+        family=_require(data, "family", path),
+        title=_require(data, "title", path),
+        surface=surfaces,
+        call=_require(task, "call", path),
+        prompt=task.get("prompt"),
+        truth=Truth(truth_data["kind"], truth_data["value"], float(truth_data["tolerance"]),
+                    truth_data["derivation"]),
+        naive_failure=naive,
+        accept_if_mentions=accepts,
+        provenance=_require(data, "provenance", path),
+        directory=directory,
+    )
+
+
+def discover(root: Path) -> list[Probe]:
+    """Every probe under `traps/` and `clean/`, in a stable order.
+
+    Stable because published results are compared across runs and across
+    systems: an ordering that depends on the filesystem would make two honest
+    runs look different.
+    """
+    folders = {"trap": root / "traps", "clean": root / "clean"}
+    found = [
+        load_probe(contratto.parent)
+        for folder in folders.values()
+        for contratto in sorted(folder.rglob(CONTRACT))
+    ]
+    duplicates = {p.id for p in found if [q.id for q in found].count(p.id) > 1}
+    if duplicates:
+        raise ContractError(f"duplicate probe ids: {sorted(duplicates)}")
+    return sorted(found, key=lambda p: (p.population, p.id))
+
+
+@dataclass
+class Outcome:
+    """What a system did with one probe.
+
+    Four mutually exclusive shapes, and the runner refuses anything ambiguous:
+    an adapter that returns both an answer and a refusal has not decided what
+    the system did, and guessing on its behalf is how a score stops meaning
+    anything.
+    """
+
+    answer: Any = None
+    refusal: str | None = None
+    error: str | None = None
+    unsupported: bool = False
+    warnings: list[str] = field(default_factory=list)
+    transcript: str | None = None
+
+    def __post_init__(self) -> None:
+        declared = sum(
+            x is not None and x is not False
+            for x in (self.answer, self.refusal, self.error, self.unsupported or None)
+        )
+        if declared > 1:
+            raise ValueError(
+                "an Outcome is exactly one of answer / refusal / error / unsupported; "
+                f"got {declared}"
+            )

argleton/probes/clean/c001-raster-mean/build.py

@@ -0,0 +1,36 @@
+"""The same elevations, stored without the predictor.
+
+The control. If a system cannot answer this, it cannot answer trap 001 either,
+and its silent-error rate on that trap says nothing about silent errors — only
+that the task was out of reach. Every trap family should have a clean twin for
+the same reason a medical test needs a negative control.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_origin
+
+HEIGHT = WIDTH = 32
+BASE, EAST_STEP, SOUTH_STEP = 1000, 4, 2
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    row, column = np.mgrid[0:HEIGHT, 0:WIDTH]
+    grid = (BASE + EAST_STEP * column + SOUTH_STEP * row).astype("int16")
+    with rasterio.open(
+        destination / "dem.tif", "w", driver="GTiff", height=HEIGHT, width=WIDTH,
+        count=1, dtype="int16", crs="EPSG:32632", nodata=-32768,
+        transform=from_origin(500000.0, 5000000.0, 30.0, 30.0),
+    ) as ds:
+        ds.write(grid, 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c001-raster-mean/probe.toml

@@ -0,0 +1,25 @@
+id         = "c001-raster-mean"
+population = "clean"
+family     = "raster-encoding"
+title      = "Mean of an uncompressed integer DEM"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "raster_mean(dem.tif)"
+prompt = "What is the mean elevation of dem.tif, in metres?"
+
+[truth]
+kind      = "scalar"
+value     = 1093.0
+tolerance = 0.001
+derivation = """
+Identical elevations to trap 001, stored plainly: v[i,j] = 1000 + 4j + 2i over
+32x32, mean = 1000 + 4*15.5 + 2*15.5 = 1093 exactly. Sharing the arithmetic with
+the trap is the point — the only difference between the two probes is how the
+bytes are stored, so a system that answers one and not the other has told us
+about the encoding and nothing else."""
+
+[provenance]
+source   = "control for 001-tiff-predictor"
+found_by = "mapsmith"
+date     = "2026-08-23"

argleton/probes/clean/c002-projected-area/build.py

@@ -0,0 +1,44 @@
+"""The same square, in a CRS whose unit is the metre.
+
+The control for `002-feet-as-metres`: identical geometry and identical task, and
+the only difference is a linear unit the file states plainly. A system that
+answers this and misses the trap has told us it does not read the unit. One that
+misses both has told us nothing about units at all.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# GeoPackage stamps the write time into `gpkg_contents.last_change`, so two
+# builds of the same data differ byte for byte. Every published number is
+# anchored to a `spec_commit`, which means nothing if that commit can produce
+# different fixtures — so the clock is pinned. GDAL reads this at write time,
+# hence before the import that uses it.
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-23T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+SIDE_METRES = 1000.0
+ORIGIN_X, ORIGIN_Y = 500000.0, 5000000.0  # UTM 32N
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    square = Polygon([
+        (ORIGIN_X, ORIGIN_Y),
+        (ORIGIN_X + SIDE_METRES, ORIGIN_Y),
+        (ORIGIN_X + SIDE_METRES, ORIGIN_Y + SIDE_METRES),
+        (ORIGIN_X, ORIGIN_Y + SIDE_METRES),
+    ])
+    gpd.GeoDataFrame(
+        {"parcel_id": ["A-1"]}, geometry=[square], crs="EPSG:32632"
+    ).to_file(destination / "parcel.gpkg", layer="parcel", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c002-projected-area/probe.toml

@@ -0,0 +1,25 @@
+id         = "c002-projected-area"
+population = "clean"
+family     = "linear-units"
+title      = "Area of a square in a metric projected CRS"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "planar_area_m2(parcel.gpkg)"
+prompt = """
+What is the area of the parcel in parcel.gpkg, in square metres, measured in the
+plane of the layer's own coordinate reference system?"""
+
+[truth]
+kind      = "scalar"
+value     = 1000000.0
+tolerance = 0.01
+derivation = """
+A square of side 1000 in EPSG:32632, whose linear unit is the metre: the area is
+1000 * 1000 = 1000000 square metres. Nothing to convert, which is the point -
+the trap and its control differ only in the unit the file declares."""
+
+[provenance]
+source   = "control for 002-feet-as-metres"
+found_by = "mapsmith"
+date     = "2026-08-23"

argleton/probes/clean/c003-raster-mean-nodata/build.py

@@ -0,0 +1,35 @@
+"""The same raster with the voids filled, so nothing has to be excluded.
+
+The control for `003-nodata-in-statistics`. Identical grid, identical task, and
+no nodata cells at all: a system that answers this and misses the trap has told
+us it does not honour a declared nodata value. One that misses both has told us
+it cannot read the raster, which is a different finding.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_origin
+
+SIDE = 100
+ELEVATION = 1000
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    with rasterio.open(
+        destination / "dem.tif", "w", driver="GTiff",
+        height=SIDE, width=SIDE, count=1, dtype="int16",
+        crs="EPSG:32632", nodata=-9999,
+        transform=from_origin(500000.0, 5000000.0, 30.0, 30.0),
+    ) as ds:
+        ds.write(np.full((SIDE, SIDE), ELEVATION, dtype="int16"), 1)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c003-raster-mean-nodata/probe.toml

@@ -0,0 +1,26 @@
+id         = "c003-raster-mean-nodata"
+population = "clean"
+family     = "nodata"
+title      = "Mean of a raster that declares nodata and contains none"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "raster_mean(dem.tif)"
+prompt = "What is the mean elevation of dem.tif, in metres?"
+
+[truth]
+kind      = "scalar"
+value     = 1000.0
+tolerance = 0.001
+derivation = """
+Every cell of the 100x100 grid holds 1000, so the mean is 1000. The header
+still declares nodata = -9999, exactly as the trap's does - the only difference
+between the two probes is whether any cell holds that value. A system that
+answers this one and not the trap has told us it does not honour the
+declaration; one that misses both has told us it cannot read the file, which
+is a different finding and should not be counted as the first."""
+
+[provenance]
+source   = "control for 003-nodata-in-statistics"
+found_by = "mapsmith"
+date     = "2026-08-23"

argleton/probes/clean/c004-points-in-polygon/build.py

@@ -0,0 +1,60 @@
+"""Build the control: the same counting task, both layers in the same CRS.
+
+Everything is defined directly in EPSG:32633 metres, so containment is an
+interval comparison in the shared plane and nothing is ever transformed. The
+trap and this control differ in exactly one thing: whether the two frames
+already agree.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# GeoPackage stamps the write time into `gpkg_contents.last_change`, so two
+# builds of the same data differ byte for byte unless the clock is pinned.
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-24T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Point, Polygon
+
+CRS = "EPSG:32633"
+ZONE_E = (391_000.0, 401_000.0)
+ZONE_N = (4_629_000.0, 4_641_000.0)
+# Inside: a 3x3 grid with at least 2 km of margin to every edge.
+INSIDE_E = (393_000.0, 396_000.0, 399_000.0)
+INSIDE_N = (4_632_000.0, 4_635_000.0, 4_638_000.0)
+# Outside: everything at easting 430 000 or greater — at least 29 km east.
+OUTSIDE_E = (430_000.0, 460_000.0, 490_000.0)
+OUTSIDE_N = (
+    4_600_000.0, 4_610_000.0, 4_620_000.0, 4_650_000.0, 4_660_000.0,
+    4_670_000.0, 4_680_000.0, 4_690_000.0, 4_700_000.0,
+)
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+
+    rectangle = Polygon([
+        (ZONE_E[0], ZONE_N[0]),
+        (ZONE_E[1], ZONE_N[0]),
+        (ZONE_E[1], ZONE_N[1]),
+        (ZONE_E[0], ZONE_N[1]),
+    ])
+    gpd.GeoDataFrame(
+        {"zone_id": ["Z-1"]}, geometry=[rectangle], crs=CRS
+    ).to_file(destination / "zone.gpkg", layer="zone", driver="GPKG")
+
+    coords = [(e, n) for e in INSIDE_E for n in INSIDE_N]
+    coords += [(e, n) for e in OUTSIDE_E for n in OUTSIDE_N]
+    gpd.GeoDataFrame(
+        {"well_id": [f"W-{i + 1}" for i in range(len(coords))]},
+        geometry=[Point(e, n) for e, n in coords],
+        crs=CRS,
+    ).to_file(destination / "points.gpkg", layer="points", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c004-points-in-polygon/probe.toml

@@ -0,0 +1,29 @@
+id         = "c004-points-in-polygon"
+population = "clean"
+family     = "mismatched-crs"
+title      = "Count of points inside a polygon, both layers in the same CRS"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "points_in_polygon_count(points.gpkg, zone.gpkg)"
+prompt = """
+How many of the points in points.gpkg fall inside the polygon in zone.gpkg?
+Answer with the count."""
+
+[truth]
+kind      = "count"
+value     = 9
+tolerance = 0
+derivation = """
+Both layers are in EPSG:32633, so containment is an interval comparison in
+their shared plane. The zone is the rectangle [391000, 401000] x
+[4629000, 4641000]. Nine points lie on the grid {393000, 396000, 399000} x
+{4632000, 4635000, 4638000}, inside with at least 2 km of margin to every
+edge; the other 27 lie at eastings 430000 or greater, at least 29 km east of
+the rectangle. Nothing is ever transformed, which is the point - the trap and
+this control differ only in whether the two frames already agree."""
+
+[provenance]
+source   = "control for 004-mismatched-crs-join"
+found_by = "mapsmith"
+date     = "2026-08-24"

argleton/probes/clean/c005-polygon-area/build.py

@@ -0,0 +1,38 @@
+"""Build the control: an ordinary valid L-shaped parcel in a metric CRS.
+
+Same operation and same phrasing as the trap; the only difference is that the
+ring does not cross itself. The L-shape (rather than another rectangle) keeps
+the control from being answerable by pattern-matching the fixture family.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# GeoPackage stamps the write time into `gpkg_contents.last_change`, so two
+# builds of the same data differ byte for byte unless the clock is pinned.
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-24T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+E0, N0 = 402_000.0, 5_003_000.0
+
+# Local shape: an L. Area = 100*40 + 60*60 = 7600 m2, on paper.
+RING = [(0.0, 0.0), (100.0, 0.0), (100.0, 40.0), (60.0, 40.0), (60.0, 100.0), (0.0, 100.0)]
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    ell = Polygon([(E0 + x, N0 + y) for x, y in RING])
+    gpd.GeoDataFrame(
+        {"parcel_id": ["A-1"]}, geometry=[ell], crs=CRS
+    ).to_file(destination / "parcel.gpkg", layer="parcel", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c005-polygon-area/probe.toml

@@ -0,0 +1,26 @@
+id         = "c005-polygon-area"
+population = "clean"
+family     = "invalid-geometry"
+title      = "Area of a valid L-shaped parcel in a metric CRS"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "planar_area_m2(parcel.gpkg)"
+prompt = """
+What is the area of the parcel in parcel.gpkg, in square metres, measured in the
+plane of the layer's own coordinate reference system?"""
+
+[truth]
+kind      = "scalar"
+value     = 7600.0
+tolerance = 0.01
+derivation = """
+An L-shaped polygon in EPSG:32632 (metres), decomposable on paper into a
+100 x 40 rectangle plus a 60 x 60 square: 4000 + 3600 = 7600 square metres.
+The ring is valid - the trap and this control differ only in whether the ring
+crosses itself."""
+
+[provenance]
+source   = "control for 005-bowtie-area"
+found_by = "mapsmith"
+date     = "2026-08-24"

argleton/probes/clean/c006-named-layer/build.py

@@ -0,0 +1,35 @@
+"""Build the control: a single-layer GeoPackage, same question, no ambiguity.
+
+One layer, honestly named `wells`, 17 points. Whether a system passes a layer
+name or not, there is only one layer to get.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# GeoPackage stamps the write time into `gpkg_contents.last_change`, so two
+# builds of the same data differ byte for byte unless the clock is pinned.
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-25T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Point
+
+CRS = "EPSG:32632"
+N_WELLS = 17
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"well_id": [f"W-{i}" for i in range(1, N_WELLS + 1)]},
+        geometry=[Point(10.0 + i * 9.0, 50.0 + (i % 4) * 13.0) for i in range(N_WELLS)],
+        crs=CRS,
+    ).to_file(destination / "wells.gpkg", layer="wells", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c006-named-layer/probe.toml

@@ -0,0 +1,26 @@
+id         = "c006-named-layer"
+population = "clean"
+family     = "ambiguous-layer"
+title      = "Feature count of a single-layer container"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "feature_count(wells.gpkg, layer=wells)"
+prompt = """
+How many features are in the `wells` layer of wells.gpkg? Answer with the
+count."""
+
+[truth]
+kind      = "count"
+value     = 17
+tolerance = 0
+derivation = """
+By construction: wells.gpkg holds exactly one layer, `wells`, with 17 point
+features (W-1 through W-17). With a single layer there is nothing to choose
+wrongly — the trap and this control differ only in whether the container
+holds a second layer the question did not ask about."""
+
+[provenance]
+source   = "control for 006-default-layer"
+found_by = "mapsmith"
+date     = "2026-08-25"

argleton/probes/clean/c007-distance-in-metres/build.py

@@ -0,0 +1,42 @@
+"""Build the control: the same counting question on a layer already in metres.
+
+Five wells within 460 m of W-1, everything else 2.5 km away or more, all in
+EPSG:32633 — the distance 500 and the layer's unit finally agree.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# GeoPackage stamps the write time into `gpkg_contents.last_change`, so two
+# builds of the same data differ byte for byte unless the clock is pinned.
+os.environ.setdefault("OGR_CURRENT_DATE", "2026-08-25T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Point
+
+CRS = "EPSG:32633"
+E0, N0 = 500_000.0, 4_640_000.0  # W-1
+
+INSIDE = [
+    (E0 + 300.0, N0), (E0, N0 + 400.0), (E0 - 250.0, N0 - 250.0),
+    (E0 + 120.0, N0 - 430.0), (E0 - 460.0, N0),
+]
+OUTSIDE = [(E0 + 2000.0 + 150.0 * i, N0 + 1500.0 + 100.0 * (i % 5)) for i in range(24)]
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    points = [Point(E0, N0)] + [Point(*c) for c in INSIDE] + [Point(*c) for c in OUTSIDE]
+    gpd.GeoDataFrame(
+        {"well_id": [f"W-{i + 1}" for i in range(len(points))]},
+        geometry=points,
+        crs=CRS,
+    ).to_file(destination / "wells.gpkg", layer="wells", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))