argleton 0.1.0__py3-none-any.whl

argleton/probes/clean/c007-distance-in-metres/probe.toml

@@ -0,0 +1,27 @@
+id         = "c007-distance-in-metres"
+population = "clean"
+family     = "implicit-parameter-units"
+title      = "Count of wells within a distance, layer already in metres"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "count_within_distance(wells.gpkg, target=W-1, distance_meters=500)"
+prompt = """
+How many other wells in wells.gpkg lie within 500 meters of the well W-1?
+Answer with the count."""
+
+[truth]
+kind      = "count"
+value     = 5
+tolerance = 0
+derivation = """
+By construction in EPSG:32633 (metres), by Pythagoras on the offsets from W-1:
+300, 400, ~354, ~446 and 460 metres for the five inside wells; every other
+well lies 2,500 m away or more. The farthest included (460) and the nearest
+excluded (2,500) leave no boundary case: the count is 5. The trap and this
+control differ only in whether the layer's unit is the one the question uses."""
+
+[provenance]
+source   = "control for 007-buffer-in-degrees"
+found_by = "mapsmith"
+date     = "2026-08-25"

argleton/probes/clean/c008-equal-area-crs/build.py

@@ -0,0 +1,39 @@
+"""Build the clean twin of 008: the same question where the plane tells the truth.
+
+The parcel is an exact 100 x 100 rectangle in EPSG:3035 (Lambert Azimuthal
+Equal-Area over Europe), at the same latitude as the trap. LAEA preserves area
+by construction, so here — and only here — the planar shoelace IS the ground
+area, and the composition that falls into 008 answers this one correctly.
+Without this twin, a failure on 008 could not be told apart from "the system
+cannot measure an area 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 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 box
+
+CRS = "EPSG:3035"
+X0, Y0, SIDE = 4_532_000.0, 2_050_000.0, 100.0  # ~12.52E 41.52N
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"parcel_id": ["P-1"]},
+        geometry=[box(X0, Y0, X0 + SIDE, Y0 + SIDE)],
+        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/c008-equal-area-crs/probe.toml

@@ -0,0 +1,37 @@
+id         = "c008-equal-area-crs"
+population = "clean"
+family     = "projection-distortion"
+title      = "The same area question where the plane tells the truth"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "ground_area_m2(parcel.gpkg)"
+prompt = """
+parcel.gpkg holds one land parcel in central Italy. How large is the parcel
+on the ground, in square metres? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 10000.0
+tolerance = 8.0
+derivation = """
+The parcel is an exact 100 x 100 rectangle in EPSG:3035, a Lambert Azimuthal
+Equal-Area projection: equal-area by construction, so its planar area IS the
+ground (ellipsoidal) area — 10000 m2 exactly. Checked against the WGS84
+geodesic area of the same footprint: 10000.000004 m2. A UTM 33N planar
+measurement, 210 km from the central meridian, reads 10002.55 m2 (scale
+factor squared); the tolerance of 8 admits it. Every correct method lands
+within 3 m2 of the truth."""
+
+[provenance]
+source = """
+Clean twin of 008-web-mercator-area: same question, same file layout, same
+feature count, an equally ordinary projected CRS in metres. The one thing
+that changed is that this projection preserves area. A system that answers
+this and fails 008 mishandles distortion, not areas; a system that fails
+both cannot answer the question, which is a different (and lesser) finding."""
+found_by = "mapsmith"
+date     = "2026-08-25"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c009-native-resolution-classes/build.py

@@ -0,0 +1,51 @@
+"""Clean twin of 009: the same question where the urban class is really there.
+
+Same legend, same CRS, already on the 15 m grid the question asks for, and
+four cells genuinely coded urban. A system that can read a class map and add
+up the area of one class answers 900; the trap's answer is zero. Without this
+twin, a zero on the trap could not be told apart from "cannot do the task".
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_origin
+
+CRS = "EPSG:32633"
+CELL = 15.0
+# Four genuinely urban cells (2), the rest forest and water.
+CLASSES = np.array(
+    [
+        [1, 1, 2, 3],
+        [1, 1, 2, 3],
+        [1, 1, 2, 3],
+        [1, 1, 2, 3],
+    ],
+    dtype="uint8",
+)
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    with rasterio.open(
+        destination / "landcover.tif",
+        "w",
+        driver="GTiff",
+        height=CLASSES.shape[0],
+        width=CLASSES.shape[1],
+        count=1,
+        dtype="uint8",
+        crs=CRS,
+        transform=from_origin(500000, 4600000, CELL, CELL),
+    ) as ds:
+        ds.write(CLASSES, 1)
+        ds.update_tags(legend="1=forest, 2=urban, 3=water")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c009-native-resolution-classes/probe.toml

@@ -0,0 +1,31 @@
+id         = "c009-native-resolution-classes"
+population = "clean"
+family     = "categorical-resampling"
+title      = "The same urban-area question, with urban actually present"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "class_area_m2(landcover.tif, resolution=15, class=2)"
+prompt = """
+landcover.tif is a land-cover map with the legend 1=forest, 2=urban, 3=water.
+Put it on a 15 metre grid so it lines up with another dataset, and report how
+many square metres of URBAN (class 2) it contains. Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 900.0
+tolerance = 0.0
+derivation = """
+The file is already on the 15 m grid the question asks for, so no resampling
+is needed and none can change the answer: the third column of a 4x4 grid is
+coded 2, which is 4 cells of 15 x 15 = 225 m2 each, so 900 m2 exactly.
+Deliberately the same number the trap's naive answer produces — what separates
+the two probes is not the quantity but whether the class is in the data."""
+
+[provenance]
+source   = "control for 009-resampled-classes"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+rasterio = "1.5.1"

argleton/probes/clean/c010-physical-values/build.py

@@ -0,0 +1,49 @@
+"""Clean twin of 010: the same question on a scene already in physical units.
+
+Same two bands, same question, no scale and no offset to apply — the values in
+the file are the reflectances. Red 0.2 and NIR 0.6 give an NDVI of 0.5, a
+different number from the trap's so the two cannot be confused in a log.
+
+A system that answers this and misses the trap can compute NDVI and ignores
+declared scaling; a system that misses both cannot compute NDVI at all, which
+is a different and lesser finding.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import rasterio
+from rasterio.transform import from_origin
+
+CRS = "EPSG:32633"
+CELL = 10.0
+RED, NIR = 0.2, 0.6
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    shape = (4, 4)
+    with rasterio.open(
+        destination / "scene.tif",
+        "w",
+        driver="GTiff",
+        height=shape[0],
+        width=shape[1],
+        count=2,
+        dtype="float32",
+        crs=CRS,
+        transform=from_origin(500000, 4600000, CELL, CELL),
+    ) as ds:
+        ds.write(np.full(shape, RED, dtype="float32"), 1)
+        ds.write(np.full(shape, NIR, dtype="float32"), 2)
+        ds.set_band_description(1, "red")
+        ds.set_band_description(2, "nir")
+        ds.update_tags(note="surface reflectance, already in physical units")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c010-physical-values/probe.toml

@@ -0,0 +1,30 @@
+id         = "c010-physical-values"
+population = "clean"
+family     = "radiometric-scale-offset"
+title      = "The same index on a scene already in physical units"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "ndvi_mean(scene.tif, red_band=1, nir_band=2)"
+prompt = """
+scene.tif holds two bands of an optical satellite scene: band 1 is red, band 2
+is near-infrared. Compute the mean NDVI, (NIR - RED) / (NIR + RED). Answer with
+the number."""
+
+[truth]
+kind      = "scalar"
+value     = 0.5
+tolerance = 0.0001
+derivation = """
+The bands are float reflectances with no scale and no offset declared: red 0.2,
+NIR 0.6 in every pixel. NDVI = (0.6 - 0.2) / (0.6 + 0.2) = 0.4 / 0.8 = 0.5
+exactly. Deliberately a different number from the trap's, so the two cannot be
+confused when reading a run."""
+
+[provenance]
+source   = "control for 010-scale-offset"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+rasterio = "1.5.1"

argleton/probes/clean/c011-solid-parcel/build.py

@@ -0,0 +1,52 @@
+"""Clean twin of 011: the same parcel with no courtyard.
+
+100 x 100 with no inner ring: 10000 m2, and no subtraction to get wrong.
+"""
+
+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-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"parcel_id": ["P-1"]},
+        geometry=[rect(0, 0, 100, 100)],
+        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/c011-solid-parcel/probe.toml

@@ -0,0 +1,28 @@
+id         = "c011-solid-parcel"
+population = "clean"
+family     = "polygon-holes"
+title      = "The same parcel with no courtyard"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "buildable_area_m2(parcel.gpkg)"
+prompt = """
+parcel.gpkg holds one parcel with an internal courtyard. How many square
+metres can be built on? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 10000.0
+tolerance = 0.01
+derivation = """
+A 100 x 100 square with no inner ring: 10000 m2 exactly, and no subtraction
+to get wrong. A system that answers this and misses the trap handles rings,
+not areas."""
+
+[provenance]
+source   = "control for 011-polygon-holes"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c012-disjoint-concessions/build.py

@@ -0,0 +1,56 @@
+"""Clean twin of 012: two concessions that do not touch.
+
+Same two 10000 m2 squares, 60 m apart. Sum and union agree at 20000, so a
+system that adds areas answers this one correctly.
+"""
+
+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-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"licence": ["L-1", "L-2"], "area_m2": [10000.0, 10000.0]},
+        geometry=[
+            rect(0, 0, 100, 100),
+            rect(160, 0, 260, 100),
+        ],
+        crs=CRS,
+    ).to_file(destination / "overlap.gpkg", layer="licences", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c012-disjoint-concessions/probe.toml

@@ -0,0 +1,28 @@
+id         = "c012-disjoint-concessions"
+population = "clean"
+family     = "double-counting"
+title      = "The same question where the concessions do not overlap"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "total_ground_area_m2(overlap.gpkg)"
+prompt = """
+The two concessions in overlap.gpkg overlap in part. How much ground do they
+cover in total, in square metres? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 20000.0
+tolerance = 0.01
+derivation = """
+The same two 10000 m2 squares, 60 m apart and disjoint. Sum and union agree
+at 20000, so a system that adds areas answers this one correctly — which is
+what makes the habit survive."""
+
+[provenance]
+source   = "control for 012-double-counting"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c013-flat-pipeline/build.py

@@ -0,0 +1,42 @@
+"""Clean twin of 013: the same pipeline on flat ground.
+
+From (0, 0, 0) to (500, 0, 0): 3D and 2D length agree at 500 m, so a system
+that ignores Z answers this one correctly.
+"""
+
+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-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import LineString
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"pipe_id": ["PL-1"]},
+        geometry=[LineString([(EAST + 0, NORTH + 0, 0), (EAST + 500, NORTH + 0, 0)])],
+        crs=CRS,
+    ).to_file(destination / "pipeline.gpkg", layer="pipeline", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c013-flat-pipeline/probe.toml

@@ -0,0 +1,28 @@
+id         = "c013-flat-pipeline"
+population = "clean"
+family     = "z-dimension"
+title      = "The same pipe on flat ground"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "pipe_length_m(pipeline.gpkg)"
+prompt = """
+pipeline.gpkg holds a pipe with elevations. How many metres of pipe are
+needed? Answer with the number."""
+
+[truth]
+kind      = "scalar"
+value     = 500.0
+tolerance = 0.01
+derivation = """
+From (0, 0, 0) to (500, 0, 0): the pipe is flat, so 3D and 2D length agree at
+500 m. A system that ignores Z answers this one correctly, which is how the
+habit stays invisible."""
+
+[provenance]
+source   = "control for 013-z-dimension"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c014-convex-parcel/build.py

@@ -0,0 +1,70 @@
+"""Clean twin of 014: a rectangular parcel, centroid inside it.
+
+Same question, same districts, but the parcel is convex — so the centroid
+falls where the parcel is, and locating by centroid gives the right district.
+"""
+
+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-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+
+def l_shape() -> Polygon:
+    """The L: a 100x20 bar plus a 20x80 upright, 3600 m2, centroid in the notch."""
+    return Polygon([
+        (EAST + 0, NORTH + 0), (EAST + 100, NORTH + 0), (EAST + 100, NORTH + 20),
+        (EAST + 20, NORTH + 20), (EAST + 20, NORTH + 100), (EAST + 0, NORTH + 100),
+    ])
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    gpd.GeoDataFrame(
+        {"parcel_id": ["P-1"]},
+        geometry=[rect(0, 0, 100, 20)],
+        crs=CRS,
+    ).to_file(destination / "parcel.gpkg", layer="parcel", driver="GPKG")
+    gpd.GeoDataFrame(
+        {"district": ["A", "B"]},
+        geometry=[
+            l_shape(),
+            rect(20, 20, 100, 100),
+        ],
+        crs=CRS,
+    ).to_file(destination / "districts.gpkg", layer="districts", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))

argleton/probes/clean/c014-convex-parcel/probe.toml

@@ -0,0 +1,28 @@
+id         = "c014-convex-parcel"
+population = "clean"
+family     = "centroid-outside"
+title      = "The same question for a parcel whose centroid is inside it"
+surface    = ["engine", "agent"]
+
+[task]
+call   = "district_of_parcel(parcel.gpkg, districts.gpkg)"
+prompt = """
+Which district is the depot in? Its parcel is in parcel.gpkg and the
+districts are in districts.gpkg. Answer with the district name."""
+
+[truth]
+kind      = "scalar"
+value     = "A"
+tolerance = 0
+derivation = """
+The parcel is the 100 x 20 rectangle, entirely inside district A, and convex —
+so its centroid at (50, 10) is on it and in A. Centroid and containment agree,
+and a system that uses the centroid answers this one correctly."""
+
+[provenance]
+source   = "control for 014-centroid-outside"
+found_by = "mapsmith"
+date     = "2026-08-26"
+
+[provenance.engine_versions]
+geopandas = "1.1.4/shapely 2.1.2"

argleton/probes/clean/c015-wells-off-the-seam/build.py

@@ -0,0 +1,73 @@
+"""Clean twin of 015: the same partition, no well on the boundary.
+
+The four seam wells move one metre west. Strict containment and boundary
+inclusion agree at 12, so a system that uses `within` answers this one
+correctly.
+"""
+
+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-26T00:00:00.000Z")
+
+import geopandas as gpd
+from shapely.geometry import Point, Polygon
+
+CRS = "EPSG:32632"
+# The fixture sits where it says it is: EPSG:32632 coordinates near Milan
+# rather than at (0, 0), which in that CRS is 500 km west of the central
+# meridian and on the equator — a point in the Atlantic where the projection
+# distorts area by 27%. A translation changes no area, no length and no count,
+# so every truth in this family is unaffected; what changes is that the file
+# stops implying something false.
+EAST, NORTH = 500_000.0, 5_030_000.0
+
+
+
+
+def rect(x0: float, y0: float, x1: float, y1: float) -> Polygon:
+    """A rectangle in local metres, placed at the fixture's real-world origin."""
+    return Polygon([
+        (EAST + x0, NORTH + y0),
+        (EAST + x1, NORTH + y0),
+        (EAST + x1, NORTH + y1),
+        (EAST + x0, NORTH + y1),
+    ])
+
+
+
+def at(x: float, y: float) -> Point:
+    """A point in local metres, placed at the fixture's real-world origin."""
+    return Point(EAST + x, NORTH + y)
+
+
+def main(destination: Path) -> int:
+    destination.mkdir(parents=True, exist_ok=True)
+    wells = [
+        (10, 10), (20, 30), (30, 60), (40, 80),
+        (60, 10), (70, 30), (80, 60), (90, 80),
+        (49, 20), (49, 40), (49, 60), (49, 80),
+    ]
+    gpd.GeoDataFrame(
+        {"well_id": [f"W-{i + 1}" for i in range(len(wells))]},
+        geometry=[at(x, y) for x, y in wells],
+        crs=CRS,
+    ).to_file(destination / "wells.gpkg", layer="wells", driver="GPKG")
+    gpd.GeoDataFrame(
+        {"district": ["west", "east"]},
+        geometry=[
+            rect(0, 0, 50, 100),
+            rect(50, 0, 100, 100),
+        ],
+        crs=CRS,
+    ).to_file(destination / "districts.gpkg", layer="districts", driver="GPKG")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(Path(sys.argv[1] if len(sys.argv) > 1 else ".")))