sverify 0.2.0__tar.gz

sverify-0.2.0/.gitignore

@@ -0,0 +1,14 @@
+/.lake
+/float-bounds/.lake
+/python/.venv
+.hypothesis/
+.pytest_cache/
+__pycache__/
+/python/src/sverify/_bin/
+/python/build/
+/python/dist/
+/python/wheelhouse/
+__marimo__/
+# Great Docs build output (`poe docs`)
+/python/great-docs/
+/python/.great-docs*/

sverify-0.2.0/.python-version

@@ -0,0 +1 @@
+3.12

sverify-0.2.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.5
+Name: sverify
+Version: 0.2.0
+Summary: Contracts and incremental views, proven in Lean, on DuckDB, Polars, DataFusion, Snowflake and Spark
+Project-URL: Homepage, https://github.com/AlexanderNenninger/substrait-lean
+Project-URL: Documentation, https://alexandernenninger.github.io/substrait-lean/
+Project-URL: Source, https://github.com/AlexanderNenninger/substrait-lean
+Project-URL: Issues, https://github.com/AlexanderNenninger/substrait-lean/issues
+Author-email: Alexander Nenninger <alexander.nenninger@live.de>
+Requires-Python: >=3.12
+Requires-Dist: duckdb>=2.0.0
+Requires-Dist: ibis-framework[duckdb]>=12.0.0
+Requires-Dist: pyarrow>=26.0.0
+Requires-Dist: substrait>=0.37.0
+Provides-Extra: all
+Requires-Dist: datafusion==51.0.0; extra == 'all'
+Requires-Dist: deltalake>=1.6.6; extra == 'all'
+Requires-Dist: numpy>=2.5.4; extra == 'all'
+Requires-Dist: polars>=2.1.0; extra == 'all'
+Requires-Dist: pyiceberg[pyarrow]>=0.12.0; extra == 'all'
+Requires-Dist: pyspark>=4.0; extra == 'all'
+Provides-Extra: datafusion
+Requires-Dist: datafusion==51.0.0; extra == 'datafusion'
+Provides-Extra: delta
+Requires-Dist: deltalake>=1.6.6; extra == 'delta'
+Provides-Extra: iceberg
+Requires-Dist: pyiceberg[pyarrow]>=0.12.0; extra == 'iceberg'
+Provides-Extra: polars
+Requires-Dist: numpy>=2.5.4; extra == 'polars'
+Requires-Dist: polars>=2.1.0; extra == 'polars'
+Provides-Extra: spark
+Requires-Dist: pyspark>=4.0; extra == 'spark'
+Description-Content-Type: text/markdown
+
+# sverify
+
+**Prove a data pipeline's contracts before it runs, get the same result on
+[DuckDB](https://duckdb.org), [Polars](https://pola.rs),
+[DataFusion](https://datafusion.apache.org), [Spark](https://spark.apache.org)
+and Snowflake, and keep it up to date from Delta Lake and Iceberg change
+feeds.**
+
+You write a transformation in [Ibis](https://ibis-project.org) or SQL and say
+what it assumes about its inputs (`requires`) and what it guarantees about
+its output (`ensures`). A checker written in [Lean](https://lean-lang.org)
+proves the guarantees for every possible input, or says why it can't. Then:
+
+* **Contracts are proved, not tested.** `not_null`, `unique`, ranges and
+  relations between columns hold on every input that meets the
+  preconditions, and division by zero, overflow and bad casts are ruled out
+  before the job runs. Preconditions are checked on the data, or proved from
+  Delta and Iceberg metadata.
+* **One plan gives the same answer on every engine.** The checked plan runs
+  on DuckDB, Polars or DataFusion, or is written as Snowflake or Spark SQL,
+  with NULLs, integer division, NaN, ties and overflow spelled out, or it is
+  refused where an engine can't match.
+* **Results are kept up to date from the changes,** by delta plans proved
+  equal to a full recompute, read from Delta's Change Data Feed or Iceberg's
+  appends, and written to sinks exactly once, with the contract attached.
+
+```bash
+pip install sverify                # or: uv add sverify
+pip install 'sverify[all]'         # with every engine and table format
+```
+
+The core runs on DuckDB and writes DuckDB, Snowflake and Spark SQL. Extras:
+`datafusion` (also compiles SQL strings), `polars`, `spark` (needs Java 17 or
+21), `delta`, `iceberg`, or `all`. Wheels bundle the checker as a small
+native binary, for Linux (x86_64, aarch64) and macOS (arm64, x86_64), Python
+3.12 and later; elsewhere pip builds from the sdist, which needs
+[elan](https://github.com/leanprover/elan).
+
+The [API reference](https://alexandernenninger.github.io/substrait-lean/)
+documents every public function and class, for the released version. For
+coding agents, the site also publishes
+[skills](https://alexandernenninger.github.io/substrait-lean/skills.html) for
+writing contracts, pipelines and engine code with sverify
+(`npx skills add https://alexandernenninger.github.io/substrait-lean/`); they
+ship in the wheel too, under `sverify/skills/`.
+
+## In thirty lines
+
+```python
+import pyarrow as pa
+import sverify as sv
+from ibis import _
+from sverify.io import StaticSource
+
+orders = StaticSource(  # in memory; DeltaSource and IcebergSource work the same way
+    pa.table({"id": [1, 2], "customer": ["ada", "bob"], "amount": [30, 5]}), name="orders"
+)
+
+
+@sv.transform(
+    requires={"orders": [_.amount >= 0, sv.unique("id")]},
+    ensures=[_.doubled >= 22, _.doubled.notnull(), sv.unique("id")],
+)
+def big_orders(orders):
+    return orders.filter(orders.amount > 10).select(orders.id, doubled=orders.amount * 2)
+
+
+big = big_orders(orders)  # proved here, before any data runs
+big.refresh()  # computed, on DuckDB by default
+orders.apply(sv.Changes(inserts=[(3, "cy", 50)], deletes=[(1, "ada", 30)]))
+big.refresh(engine="polars")  # updated from the changes alone, on another engine
+assert big.to_arrow().to_pylist() == [{"id": 3, "doubled": 100}]
+print(big_orders.last_report)
+# requires orders: (_.amount >= 0)
+# requires orders: unique(id)
+# ensures (_.doubled >= 22): proved
+```
+
+A postcondition that doesn't follow is refused before anything runs:
+
+```python
+@sv.transform(requires={"orders": [_.amount >= 0]}, ensures=[_.total > 5])
+def plus_one(orders):
+    return orders.select(orders.id, total=orders.amount + 1)
+
+
+from sverify.errors import VerificationError
+
+try:
+    plus_one(orders)
+except VerificationError as e:
+    print(e)
+# could not prove: (_.total > 5) (it is TRUE or FALSE)
+```
+
+## SQL models
+
+A transform's body can be SQL, over its inputs by name. It is proved,
+composed and refreshed like any other:
+
+```python
+@sv.transform(
+    requires={"orders": ["amount >= 0", "amount IS NOT NULL"]},
+    ensures=["total >= 0", sv.unique("customer")],
+)
+def per_customer(orders):
+    return sv.sql(
+        "SELECT customer, coalesce(sum(amount), 0) AS total FROM orders GROUP BY customer",
+        orders=orders,
+    )
+
+
+totals = per_customer(orders)  # proved here, like an Ibis transform
+totals.refresh()
+assert sorted(totals.to_arrow().to_pylist(), key=str) == [
+    {"customer": "bob", "total": 5},
+    {"customer": "cy", "total": 50},
+]
+```
+
+Several inputs are several keywords (`sv.sql(query, orders=orders,
+customers=customers)`). The SQL is planned by DataFusion
+(`pip install 'sverify[datafusion]'`), or by Isthmus without it.
+
+## Workflows
+
+Three complete jobs from a catalogue of 139 real analytical queries, each
+from source tables to a sink, with what goes wrong without the checker. Open
+them in the browser:
+
+* [Duplicate card payments](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/01_duplicate_payments.py):
+  a self-join over a Delta table, refreshed from its Change Data Feed, where
+  a watermark job would miss a late duplicate and keep a reversed one.
+* [Sensor alerts](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/02_sensor_alerts.py):
+  `LAG` over an Iceberg table, where ties and a NaN reading change the alerts,
+  and Snowflake and Spark need proved tie-freedom.
+* [An orders mart](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/03_orders_mart.py):
+  dbt tests as a proved contract on a point-in-time join to a type-2
+  dimension, in Ibis and in SQL.
+
+The [whole tour](https://github.com/AlexanderNenninger/substrait-lean/tree/main/notebooks)
+explains every feature in a chapter of its own; it runs locally with
+`uvx marimo edit --sandbox notebooks` from a clone.
+
+## The API in brief
+
+```python
+import json
+
+import ibis
+from sverify.engines import SNOWFLAKE, to_sql  # also DUCKDB, SPARK
+from sverify.io import DeltaSink, DeltaSource  # IcebergSource, IcebergSink likewise
+
+sv.verify(
+    "select id, amount from orders where amount > 0",
+    tables={"orders": ibis.table({"id": "int64", "amount": "int64"}, name="orders")},
+    ensures=["amount > 0"],
+)  # SQL, checked; returns the report
+to_sql(json.loads(big.plan), SNOWFLAKE)  # the checked plan, or sverify.engines.Unsupported
+
+# p = paid(DeltaSource("s3://.../orders")).write(DeltaSink("s3://.../paid"))  # stored: a source
+# r = revenue(p).write(DeltaSink("s3://.../revenue"))
+# r.refresh(engine="polars"); sv.group(r, other).refresh(); r.to_pandas()
+```
+
+* `@sv.transform(requires=..., ensures=..., on_unproved="error" | "runtime" | "warn")`
+  proves a contract on each call; `.last_report` says what was proved and
+  what is known about every output column. `sv.unique(...)` states keys.
+* Called on sources (`sverify.io`) or other nodes, transforms build nodes
+  that compose directly: a downstream precondition is proved from the
+  upstream contract (`CompositionError` names a broken link).
+* Without `.write` in between, transforms fuse into one plan; `.write(sink)`
+  stores a node, exactly once per state, and nodes downstream read it as a
+  versioned source. `refresh(engine=...)` updates the whole lineage, and
+  `sv.group(a, b)` several outputs against the same source versions.
+* Filters, projections, inner and cross joins and `UNION ALL` are
+  maintained from the changes; anything else is recomputed and diffed.
+* `sverify.engines` has the engines, SQL dialects and plans
+  (`run_sharded` runs a plan per shard and combines the results, with a
+  proof that the result is the same); `sverify.errors` the exceptions.
+
+**Not supported yet:** DECIMAL columns (keep money as integer cents),
+framed window aggregates, `RANK` and `NTILE`. The repository's README has
+the coverage table, the full guide, and what is proved and what is trusted.
+
+## Configuration
+
+* `SVERIFY_CHECK`: path to a `substrait-check` binary to use instead of the
+  bundled one, for example your own `lake build`.
+* `SVERIFY_ISTHMUS`: path to an [Isthmus](https://github.com/substrait-io/substrait-java/releases)
+  binary (otherwise `isthmus` on `PATH`), to compile SQL strings without
+  DataFusion; `sv.connect(sql_producer="isthmus")` picks it, and it is the
+  default when DataFusion is not installed. sverify doesn't ship it (~120 MB);
+  `scripts/fetch_isthmus.sh <dir>` downloads the pinned release.
+* DataFusion is pinned to 51, because Ibis 12's DataFusion backend doesn't
+  connect to later versions.
+
+## Development
+
+```bash
+git clone https://github.com/AlexanderNenninger/substrait-lean
+cd substrait-lean/python
+uv sync                          # builds substrait-check with lake (needs elan) and links it in
+uv run poe qa                    # proofs, lint, typecheck, golden, Python tests, notebooks
+```
+
+See the [repository](https://github.com/AlexanderNenninger/substrait-lean) for setup details.

sverify-0.2.0/README.md

@@ -0,0 +1,207 @@
+# sverify
+
+**Prove a data pipeline's contracts before it runs, get the same result on
+[DuckDB](https://duckdb.org), [Polars](https://pola.rs),
+[DataFusion](https://datafusion.apache.org), [Spark](https://spark.apache.org)
+and Snowflake, and keep it up to date from Delta Lake and Iceberg change
+feeds.**
+
+You write a transformation in [Ibis](https://ibis-project.org) or SQL and say
+what it assumes about its inputs (`requires`) and what it guarantees about
+its output (`ensures`). A checker written in [Lean](https://lean-lang.org)
+proves the guarantees for every possible input, or says why it can't. Then:
+
+* **Contracts are proved, not tested.** `not_null`, `unique`, ranges and
+  relations between columns hold on every input that meets the
+  preconditions, and division by zero, overflow and bad casts are ruled out
+  before the job runs. Preconditions are checked on the data, or proved from
+  Delta and Iceberg metadata.
+* **One plan gives the same answer on every engine.** The checked plan runs
+  on DuckDB, Polars or DataFusion, or is written as Snowflake or Spark SQL,
+  with NULLs, integer division, NaN, ties and overflow spelled out, or it is
+  refused where an engine can't match.
+* **Results are kept up to date from the changes,** by delta plans proved
+  equal to a full recompute, read from Delta's Change Data Feed or Iceberg's
+  appends, and written to sinks exactly once, with the contract attached.
+
+```bash
+pip install sverify                # or: uv add sverify
+pip install 'sverify[all]'         # with every engine and table format
+```
+
+The core runs on DuckDB and writes DuckDB, Snowflake and Spark SQL. Extras:
+`datafusion` (also compiles SQL strings), `polars`, `spark` (needs Java 17 or
+21), `delta`, `iceberg`, or `all`. Wheels bundle the checker as a small
+native binary, for Linux (x86_64, aarch64) and macOS (arm64, x86_64), Python
+3.12 and later; elsewhere pip builds from the sdist, which needs
+[elan](https://github.com/leanprover/elan).
+
+The [API reference](https://alexandernenninger.github.io/substrait-lean/)
+documents every public function and class, for the released version. For
+coding agents, the site also publishes
+[skills](https://alexandernenninger.github.io/substrait-lean/skills.html) for
+writing contracts, pipelines and engine code with sverify
+(`npx skills add https://alexandernenninger.github.io/substrait-lean/`); they
+ship in the wheel too, under `sverify/skills/`.
+
+## In thirty lines
+
+```python
+import pyarrow as pa
+import sverify as sv
+from ibis import _
+from sverify.io import StaticSource
+
+orders = StaticSource(  # in memory; DeltaSource and IcebergSource work the same way
+    pa.table({"id": [1, 2], "customer": ["ada", "bob"], "amount": [30, 5]}), name="orders"
+)
+
+
+@sv.transform(
+    requires={"orders": [_.amount >= 0, sv.unique("id")]},
+    ensures=[_.doubled >= 22, _.doubled.notnull(), sv.unique("id")],
+)
+def big_orders(orders):
+    return orders.filter(orders.amount > 10).select(orders.id, doubled=orders.amount * 2)
+
+
+big = big_orders(orders)  # proved here, before any data runs
+big.refresh()  # computed, on DuckDB by default
+orders.apply(sv.Changes(inserts=[(3, "cy", 50)], deletes=[(1, "ada", 30)]))
+big.refresh(engine="polars")  # updated from the changes alone, on another engine
+assert big.to_arrow().to_pylist() == [{"id": 3, "doubled": 100}]
+print(big_orders.last_report)
+# requires orders: (_.amount >= 0)
+# requires orders: unique(id)
+# ensures (_.doubled >= 22): proved
+```
+
+A postcondition that doesn't follow is refused before anything runs:
+
+```python
+@sv.transform(requires={"orders": [_.amount >= 0]}, ensures=[_.total > 5])
+def plus_one(orders):
+    return orders.select(orders.id, total=orders.amount + 1)
+
+
+from sverify.errors import VerificationError
+
+try:
+    plus_one(orders)
+except VerificationError as e:
+    print(e)
+# could not prove: (_.total > 5) (it is TRUE or FALSE)
+```
+
+## SQL models
+
+A transform's body can be SQL, over its inputs by name. It is proved,
+composed and refreshed like any other:
+
+```python
+@sv.transform(
+    requires={"orders": ["amount >= 0", "amount IS NOT NULL"]},
+    ensures=["total >= 0", sv.unique("customer")],
+)
+def per_customer(orders):
+    return sv.sql(
+        "SELECT customer, coalesce(sum(amount), 0) AS total FROM orders GROUP BY customer",
+        orders=orders,
+    )
+
+
+totals = per_customer(orders)  # proved here, like an Ibis transform
+totals.refresh()
+assert sorted(totals.to_arrow().to_pylist(), key=str) == [
+    {"customer": "bob", "total": 5},
+    {"customer": "cy", "total": 50},
+]
+```
+
+Several inputs are several keywords (`sv.sql(query, orders=orders,
+customers=customers)`). The SQL is planned by DataFusion
+(`pip install 'sverify[datafusion]'`), or by Isthmus without it.
+
+## Workflows
+
+Three complete jobs from a catalogue of 139 real analytical queries, each
+from source tables to a sink, with what goes wrong without the checker. Open
+them in the browser:
+
+* [Duplicate card payments](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/01_duplicate_payments.py):
+  a self-join over a Delta table, refreshed from its Change Data Feed, where
+  a watermark job would miss a late duplicate and keep a reversed one.
+* [Sensor alerts](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/02_sensor_alerts.py):
+  `LAG` over an Iceberg table, where ties and a NaN reading change the alerts,
+  and Snowflake and Spark need proved tie-freedom.
+* [An orders mart](https://molab.marimo.io/github/AlexanderNenninger/substrait-lean/blob/published/notebooks/03_orders_mart.py):
+  dbt tests as a proved contract on a point-in-time join to a type-2
+  dimension, in Ibis and in SQL.
+
+The [whole tour](https://github.com/AlexanderNenninger/substrait-lean/tree/main/notebooks)
+explains every feature in a chapter of its own; it runs locally with
+`uvx marimo edit --sandbox notebooks` from a clone.
+
+## The API in brief
+
+```python
+import json
+
+import ibis
+from sverify.engines import SNOWFLAKE, to_sql  # also DUCKDB, SPARK
+from sverify.io import DeltaSink, DeltaSource  # IcebergSource, IcebergSink likewise
+
+sv.verify(
+    "select id, amount from orders where amount > 0",
+    tables={"orders": ibis.table({"id": "int64", "amount": "int64"}, name="orders")},
+    ensures=["amount > 0"],
+)  # SQL, checked; returns the report
+to_sql(json.loads(big.plan), SNOWFLAKE)  # the checked plan, or sverify.engines.Unsupported
+
+# p = paid(DeltaSource("s3://.../orders")).write(DeltaSink("s3://.../paid"))  # stored: a source
+# r = revenue(p).write(DeltaSink("s3://.../revenue"))
+# r.refresh(engine="polars"); sv.group(r, other).refresh(); r.to_pandas()
+```
+
+* `@sv.transform(requires=..., ensures=..., on_unproved="error" | "runtime" | "warn")`
+  proves a contract on each call; `.last_report` says what was proved and
+  what is known about every output column. `sv.unique(...)` states keys.
+* Called on sources (`sverify.io`) or other nodes, transforms build nodes
+  that compose directly: a downstream precondition is proved from the
+  upstream contract (`CompositionError` names a broken link).
+* Without `.write` in between, transforms fuse into one plan; `.write(sink)`
+  stores a node, exactly once per state, and nodes downstream read it as a
+  versioned source. `refresh(engine=...)` updates the whole lineage, and
+  `sv.group(a, b)` several outputs against the same source versions.
+* Filters, projections, inner and cross joins and `UNION ALL` are
+  maintained from the changes; anything else is recomputed and diffed.
+* `sverify.engines` has the engines, SQL dialects and plans
+  (`run_sharded` runs a plan per shard and combines the results, with a
+  proof that the result is the same); `sverify.errors` the exceptions.
+
+**Not supported yet:** DECIMAL columns (keep money as integer cents),
+framed window aggregates, `RANK` and `NTILE`. The repository's README has
+the coverage table, the full guide, and what is proved and what is trusted.
+
+## Configuration
+
+* `SVERIFY_CHECK`: path to a `substrait-check` binary to use instead of the
+  bundled one, for example your own `lake build`.
+* `SVERIFY_ISTHMUS`: path to an [Isthmus](https://github.com/substrait-io/substrait-java/releases)
+  binary (otherwise `isthmus` on `PATH`), to compile SQL strings without
+  DataFusion; `sv.connect(sql_producer="isthmus")` picks it, and it is the
+  default when DataFusion is not installed. sverify doesn't ship it (~120 MB);
+  `scripts/fetch_isthmus.sh <dir>` downloads the pinned release.
+* DataFusion is pinned to 51, because Ibis 12's DataFusion backend doesn't
+  connect to later versions.
+
+## Development
+
+```bash
+git clone https://github.com/AlexanderNenninger/substrait-lean
+cd substrait-lean/python
+uv sync                          # builds substrait-check with lake (needs elan) and links it in
+uv run poe qa                    # proofs, lint, typecheck, golden, Python tests, notebooks
+```
+
+See the [repository](https://github.com/AlexanderNenninger/substrait-lean) for setup details.

sverify-0.2.0/great-docs.yml

@@ -0,0 +1,134 @@
+# Great Docs configuration for the sverify API reference (`uv run poe docs`).
+# See https://posit-dev.github.io/great-docs/user-guide/03-configuration.html
+#
+# The landing page is this directory's README.md (the PyPI page). The notebook
+# tour is linked on molab, not embedded: the notebooks call the native Lean
+# checker, so they can't run in the browser.
+
+module: sverify
+
+display_name: "sverify"
+
+navbar_style: "sky"
+
+parser: google
+
+# Static analysis (griffe reads the source). Runtime introspection resolves
+# `io.DeltaSource` as an attribute of `sverify`, and `import sverify` doesn't
+# import all of its submodules (`sverify.io` loads delta-rs and pyiceberg
+# lazily).
+dynamic: false
+
+# Sections in the order a data engineer looks for things: what a transform
+# promises, how its result is built, stored and kept up to date, where its
+# tables live, where it runs, what can go wrong. The public API is the ten
+# top-level names plus `sverify.io`, `sverify.engines` and `sverify.errors`;
+# everything else is internal (CHANGELOG.md, 0.2.0). `Node`'s results
+# (`Refresh`, `Status`, `Group`) live in `sverify.nodes` and are documented
+# because users hold them, not because they are imported.
+reference:
+  - title: Contracts
+    desc: >
+      State what a transformation assumes and promises, and have it proved
+      before any data runs.
+    contents:
+      - transform
+      - verify
+      - unique
+      - references
+      - Report
+
+  - title: Transforms, nodes and refresh
+    desc: >
+      A contracted transform called on a source builds a node. Nodes compose,
+      are stored with `.write(sink)`, and are kept up to date by `.refresh()`,
+      with update plans proved equal to a full recompute.
+    contents:
+      - Node
+      - group
+      - Changes
+      - nodes.Group
+      - nodes.Refresh
+      - nodes.Status
+      - nodes.NodeStatus
+      - nodes.StageRefresh
+
+  - title: Sources and sinks
+    desc: >
+      Delta Lake and Iceberg tables as versioned sources, sources of
+      preconditions, and sinks that carry the contract (`sverify.io`).
+    contents:
+      - io.DeltaSource
+      - io.DeltaSink
+      - io.IcebergSource
+      - io.IcebergSink
+      - io.StaticSource
+      - io.SinkWrite
+      - io.Contract
+
+  - title: Engines and SQL
+    desc: >
+      Run a checked plan on DuckDB, Polars, DataFusion or Spark, or write it
+      as DuckDB, Snowflake or Spark SQL (`sverify.engines`).
+    contents:
+      - connect
+      - engines.run
+      - engines.ENGINES
+      - engines.Connection
+      - engines.create_table
+      - engines.table_rows
+      - engines.to_sql
+      - engines.Dialect
+      - engines.DUCKDB
+      - engines.SNOWFLAKE
+      - engines.SPARK
+      - engines.Unsupported
+      - engines.run_spark
+      - engines.SPARK_CONF
+      - engines.run_sharded
+
+  - title: ASOF joins
+    desc: Align two time series, each row with the latest earlier row of the other.
+    contents:
+      - asof_join
+
+  - title: Plans
+    desc: >
+      The low-level layer: Substrait plans, Lean's written form of them, and
+      the update plans of incremental maintenance (`sverify.engines`).
+    contents:
+      - engines.substrait_json
+      - engines.isthmus_json
+      - engines.SQL_PRODUCERS
+      - engines.written_plan
+      - engines.run_substrait_json
+      - engines.delta_plans
+
+  - title: Errors
+    desc: What sverify raises, and when (`sverify.errors`).
+    contents:
+      - errors.VerificationError
+      - errors.PreconditionError
+      - errors.PostconditionError
+      - errors.CompositionError
+      - errors.NotIncremental
+      - errors.AuditError
+      - errors.SchemaError
+      - errors.SqlError
+
+# Agent skills for sverify users, written by hand and shipped in the wheel
+# (`sverify/skills/<name>/SKILL.md`, with their `references/`). The site
+# publishes them under `.well-known/agent-skills/` with a Skills page;
+# `tests/test_skills.py` runs their code.
+skill:
+  enabled: true
+  well_known: true
+  skills:
+    - name: sverify
+      file: src/sverify/skills/sverify/SKILL.md
+    - name: sverify-pipelines
+      file: src/sverify/skills/sverify-pipelines/SKILL.md
+    - name: sverify-engines
+      file: src/sverify/skills/sverify-engines/SKILL.md
+
+jupyter: python3

sverify-0.2.0/hatch_build.py

@@ -0,0 +1,60 @@
+"""Build `substrait-check` with lake and ship it inside the wheel.
+
+The wheel is tagged `py3-none-<platform>`: the Python code is pure, the binary
+is not. A regular wheel gets a stripped copy in `sverify/_bin/`; an editable
+install gets a symlink to `.lake/build/bin/substrait-check`, so a later
+`lake build` takes effect without reinstalling.
+
+The Lean project is the repository root, or `lean/` in an unpacked sdist.
+"""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+BINARY = "substrait-check"
+
+
+def platform_tag() -> str:
+    machine = platform.machine().lower()
+    if sys.platform == "darwin":
+        # Lean's linker records no real minimum macOS version (`minos 99.0`),
+        # so use the oldest one each architecture's toolchain supports.
+        return "macosx_11_0_arm64" if machine == "arm64" else "macosx_10_15_x86_64"
+    if sys.platform == "linux":
+        # `auditwheel repair` turns this into a manylinux tag in CI.
+        return f"linux_{machine}"
+    raise RuntimeError(f"sverify wheels are not supported on {sys.platform}")
+
+
+class LakeBuildHook(BuildHookInterface):
+    def initialize(self, version: str, build_data: dict) -> None:
+        repo = Path(self.root) / "lean"
+        if not repo.is_dir():
+            repo = Path(self.root).parent
+        lake = shutil.which("lake") or str(Path.home() / ".elan" / "bin" / "lake")
+        if not Path(lake).exists():
+            raise RuntimeError("building sverify needs `lake` (install elan) on PATH")
+        subprocess.run([lake, "build", BINARY], cwd=repo, check=True)
+
+        built = repo / ".lake" / "build" / "bin" / BINARY
+        if version == "editable":
+            link = Path(self.root) / "src" / "sverify" / "_bin" / BINARY
+            link.parent.mkdir(exist_ok=True)
+            link.unlink(missing_ok=True)
+            link.symlink_to(built)
+        else:
+            staged = Path(self.root) / "build" / BINARY
+            staged.parent.mkdir(exist_ok=True)
+            shutil.copy2(built, staged)
+            subprocess.run(["strip", str(staged)], check=True)
+            build_data["force_include"][str(staged)] = f"sverify/_bin/{BINARY}"
+
+        build_data["pure_python"] = False
+        build_data["tag"] = f"py3-none-{platform_tag()}"