Merge pull request #2 from ahrzb/chore/ci-and-lint

ahrzb · web-flow · commit d9b56060f05d · 2026-07-20T23:12:13.000+02:00
ci: GitHub Actions (Ubuntu, uv, ruff, pytest) + repo lint cleanup
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
@@ -0,0 +1,6 @@
+# Commits skipped by `git blame` — bulk, mechanical reformats with no logic changes.
+# GitHub applies this file automatically. Enable it locally with:
+#   git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# style: apply ruff format + autofix across the repo
+2708018aa86c7f9bb229bf6b422e3c1531564a30
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      # The package is a pyo3/maturin extension, so CI needs a Rust toolchain
+      # to build it during `uv sync`.
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Rust build
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      # Provisions Python 3.14 (per requires-python), builds the extension, and
+      # installs locked deps.
+      - name: Build extension + install deps
+        run: uv sync --locked
+
+      # Lint + formatting go through pre-commit so CI enforces exactly what the
+      # local hooks do (config: .pre-commit-config.yaml), rather than a second,
+      # drift-prone copy of the ruff invocations.
+      - name: Lint + format (pre-commit)
+        run: uv run pre-commit run --all-files --show-diff-on-failure
+
+      - name: Tests
+        run: uv run pytest -q
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -0,0 +1,14 @@
+# Single source of truth for lint + formatting.
+#
+# CI does not run ruff directly — it runs `pre-commit run --all-files`, so what
+# blocks a PR is exactly what runs on your machine. `rev` is pinned to the ruff
+# version locked in uv.lock; bump both together or local and CI will disagree.
+#
+# One-time local setup:  uv run pre-commit install
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.21
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
diff --git a/pyproject.toml b/pyproject.toml
@@ -19,6 +19,7 @@ dev = [
     "notebook>=7.6.0",
     "numpy>=2.0",
     "pandas>=2.0",
+    "pre-commit>=4.6.0",
     "pytest>=8.3.5",
     "ruff>=0.11.7",
     "scikit-learn>=1.5",
@@ -41,6 +42,8 @@ lint.ignore = ["S101"]
 [tool.ruff.lint.per-file-ignores]
 "*test*.py" = ["S608"]
 "_state.py" = ["S608"]
+# Doc generator: emits long markdown lines verbatim; wrapping would corrupt output.
+"scripts/gen_datafusion_catalogue.py" = ["E501"]
 
 [tool.pytest.ini_options]
 python_files = ["*_test.py", "test_*.py"]
diff --git a/scripts/gen_datafusion_catalogue.py b/scripts/gen_datafusion_catalogue.py
@@ -88,7 +88,12 @@ def main() -> None:
         ("Window functions", "WINDOW"),
         ("Scalar functions", "SCALAR"),
     ]:
-        lines += [f"## {title} ({len(groups[key])})", "", "| Function | Signature | Description |", "|---|---|---|"]
+        lines += [
+            f"## {title} ({len(groups[key])})",
+            "",
+            "| Function | Signature | Description |",
+            "|---|---|---|",
+        ]
         lines += [
             f"| `{name}` | {clean(syn) or '—'} | {clean(desc) or '—'} |"
             for name, _ftype, syn, desc in groups[key]
diff --git a/sql_transform/__init__.py b/sql_transform/__init__.py
@@ -93,7 +93,9 @@ def fit(
             self._rewritten_sql,
             row_tables={"__THIS__": this_model},
             static_tables=self._state_tables,
-            transformers={n: (obj, out_s) for n, (obj, in_s, out_s) in self._udf_specs.items()},
+            transformers={
+                n: (obj, out_s) for n, (obj, in_s, out_s) in self._udf_specs.items()
+            },
         )
         return self
 
@@ -105,7 +107,9 @@ def transform(self, table: pa.Table, /) -> pa.Table:
         the Rust engine instead."""
         if self._infer_fn is None:
             raise RuntimeError("Must call fit() before transform")
-        return run_batch(self._rewritten_sql, table, self._state_tables, self._udf_specs)
+        return run_batch(
+            self._rewritten_sql, table, self._state_tables, self._udf_specs
+        )
 
     def infer(self, row: dict[str, Any] | BaseModel, /) -> BaseModel:
         """Single-row inference through the Rust InferFn against the frozen
diff --git a/sql_transform/_codegen/plan.py b/sql_transform/_codegen/plan.py
@@ -191,9 +191,9 @@ class Cast:
 
 @dataclass
 class Case:
-    arms: list       # list[tuple[cond, result]]
-    default: Any     # result expr; Literal(None) when no ELSE
-    has_else: bool   # whether an explicit ELSE was written
+    arms: list  # list[tuple[cond, result]]
+    default: Any  # result expr; Literal(None) when no ELSE
+    has_else: bool  # whether an explicit ELSE was written
 
 
 @dataclass
diff --git a/sql_transform/_codegen/plan_test.py b/sql_transform/_codegen/plan_test.py
@@ -339,9 +339,7 @@ def test_infer_type_arithmetic_and_nullability():
 
 
 def test_infer_type_functions_and_casts():
-    schemas = {
-        "t": {"s": cp.FieldType(cp.STR, False), "i": cp.FieldType(cp.INT, True)}
-    }
+    schemas = {"t": {"s": cp.FieldType(cp.STR, False), "i": cp.FieldType(cp.INT, True)}}
     upper_s = cp.Func("upper", [cp.Column("t", "s")])
     assert cp.infer_type(upper_s, schemas).base == cp.STR
 
diff --git a/sql_transform/_compose.py b/sql_transform/_compose.py
@@ -28,8 +28,8 @@
 @dataclass(frozen=True)
 class Ref:
     transform: object  # a SQLTransform, or a fitted transformer if is_transformer
-    frozen: bool       # True for {a.transform}; False for bare {a}
-    expr_text: str     # interpolation source, for error messages
+    frozen: bool  # True for {a.transform}; False for bare {a}
+    expr_text: str  # interpolation source, for error messages
     is_transformer: bool = False
 
 
@@ -186,8 +186,10 @@ def fit_into_scope(
     # Remap inner's single __THIS__ column -> input_expr throughout the tree,
     # so its window aggregates are over input_expr (agg-over-expression).
     def remap(n):
-        if isinstance(n, exp.Column) and n.name == inner_col and not (
-            n.table and n.table.startswith("__STATE")
+        if (
+            isinstance(n, exp.Column)
+            and n.name == inner_col
+            and not (n.table and n.table.startswith("__STATE"))
         ):
             return input_expr.copy()
         return n
@@ -211,9 +213,11 @@ def remap(n):
     if isinstance(frozen_expr, exp.Alias):
         frozen_expr = frozen_expr.this
     frozen_expr = frozen_expr.transform(
-        lambda n: exp.column(n.name, table=scope)
-        if isinstance(n, exp.Column) and n.table in rename
-        else n
+        lambda n: (
+            exp.column(n.name, table=scope)
+            if isinstance(n, exp.Column) and n.table in rename
+            else n
+        )
     )
     return frozen_expr, scoped_state
 
diff --git a/sql_transform/_compose_test.py b/sql_transform/_compose_test.py
@@ -32,9 +32,7 @@ def test_multi_input_inner_raises_clean_value_error():
         "SELECT age / AVG(age) OVER (PARTITION BY city) AS e FROM __THIS__"
     ).fit(train)
     with pytest.raises(ValueError, match="one input column"):
-        SQLTransform(
-            t"SELECT {grouped.transform}(age) AS e2 FROM __THIS__"
-        ).fit(train)
+        SQLTransform(t"SELECT {grouped.transform}(age) AS e2 FROM __THIS__").fit(train)
 
 
 def test_frozen_reference_on_unfit_errors():
@@ -51,7 +49,9 @@ def test_bare_reference_on_fitted_transform_is_ambiguous_error_via_cascade():
     train_v = pa.table({"v": [10.0, 20.0, 30.0, 40.0]})
     train = pa.table({"age": [10.0, 20.0, 30.0, 40.0]})
     b = SQLTransform("SELECT v * 2 AS d FROM __THIS__").fit(train_v)
-    a = SQLTransform("SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__")
+    a = SQLTransform(
+        "SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__"
+    )
     with pytest.raises(ValueError, match="already fitted"):
         SQLTransform(t"SELECT {a}({b}(age)) AS z FROM __THIS__").fit(train)
 
@@ -62,7 +62,9 @@ def test_frozen_reference_on_unfit_errors_via_cascade():
     # path too.
     train = pa.table({"age": [10.0, 20.0, 30.0, 40.0]})
     b = SQLTransform("SELECT v * 2 AS d FROM __THIS__")  # unfit
-    a = SQLTransform("SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__")
+    a = SQLTransform(
+        "SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__"
+    )
     with pytest.raises(ValueError, match="not fitted"):
         SQLTransform(t"SELECT {a}({b.transform}(age)) AS z FROM __THIS__").fit(train)
 
@@ -94,9 +96,9 @@ def test_reference_not_applied_to_column_errors():
         "SELECT (age - AVG(age) OVER ()) / STDDEV(age) OVER () AS s FROM __THIS__"
     ).fit(train)
     with pytest.raises(ValueError, match="single input column"):
-        SQLTransform(
-            t"SELECT {scaler.transform}(age + 1) AS s FROM __THIS__"
-        ).fit(train)
+        SQLTransform(t"SELECT {scaler.transform}(age + 1) AS s FROM __THIS__").fit(
+            train
+        )
 
 
 def test_non_transform_interpolation_errors():
diff --git a/sql_transform/_rewrite.py b/sql_transform/_rewrite.py
@@ -69,9 +69,7 @@ def rewrite_sql(
             # Quote the join-key identifiers with their exact names -- matching
             # build_state_tables' quoted GROUP BY -- so a case-sensitive partition
             # column resolves (DataFusion folds unquoted identifiers to lowercase).
-            on = " AND ".join(
-                f'__THIS__."{c}" = {table}."{c}"' for c in partition_cols
-            )
+            on = " AND ".join(f'__THIS__."{c}" = {table}."{c}"' for c in partition_cols)
         select.join(exp.to_table(table), on=on, join_type="LEFT", copy=False)
 
     for table in extra_marker_tables:
diff --git a/sql_transform/_sql_test.py b/sql_transform/_sql_test.py
@@ -99,9 +99,7 @@ def test_find_window_aggregates_accepts_expression_argument():
 
 
 def test_find_window_aggregates_rejects_multi_arg():
-    tree = parse_and_validate(
-        "SELECT MYAGG(age, score) OVER () AS x FROM __THIS__"
-    )
+    tree = parse_and_validate("SELECT MYAGG(age, score) OVER () AS x FROM __THIS__")
     with pytest.raises(ValueError, match="exactly one argument"):
         find_window_aggregates(tree)
 
diff --git a/sql_transform/_transformer_ref.py b/sql_transform/_transformer_ref.py
@@ -21,7 +21,9 @@ def _find_call(select: exp.Select, name: str) -> exp.Anonymous:
     for n in select.find_all(exp.Anonymous):
         if str(n.this).upper() == name:
             return n
-    raise ValueError(f"transformer ref {name} must be applied to columns, e.g. {{t}}(a, b)")
+    raise ValueError(
+        f"transformer ref {name} must be applied to columns, e.g. {{t}}(a, b)"
+    )
 
 
 def _named_struct(cols: list[exp.Column]) -> exp.Anonymous:
@@ -61,7 +63,9 @@ def _materialize(
     shaped like out_schema, so an outer transformer can probe on real data."""
     x = np.column_stack([src.column(c).to_numpy(zero_copy_only=False) for c in cols])
     y = np.asarray(obj.transform(x))
-    arrays = [pa.array(y[:, i], type=out_schema.field(i).type) for i in range(len(out_schema))]
+    arrays = [
+        pa.array(y[:, i], type=out_schema.field(i).type) for i in range(len(out_schema))
+    ]
     return pa.table(arrays, schema=out_schema)
 
 
@@ -74,11 +78,15 @@ def resolve_transformer_refs(
     output, resolving innermost-first. Returns
     {placeholder_name.lower(): (obj, in_schema, out_schema)}."""
     registry: dict[str, tuple[object, pa.Schema, pa.Schema]] = {}
-    materialized: dict[str, pa.Table] = {}  # name -> this ref's output, for outer probes
+    materialized: dict[
+        str, pa.Table
+    ] = {}  # name -> this ref's output, for outer probes
 
     def call_arg_ref(call: exp.Anonymous) -> str | None:
         """If the call's single arg is another transformer-ref call, its name."""
-        if len(call.expressions) == 1 and isinstance(call.expressions[0], exp.Anonymous):
+        if len(call.expressions) == 1 and isinstance(
+            call.expressions[0], exp.Anonymous
+        ):
             inner = str(call.expressions[0].this).upper()
             if inner in tfm_refs:
                 return inner
diff --git a/sql_transform/_transformer_udf.py b/sql_transform/_transformer_udf.py
@@ -53,8 +53,7 @@ def _apply(struct_array: pa.Array) -> pa.Array:
         x = np.column_stack(cols)
         y = np.asarray(obj.transform(x))
         out_cols = [
-            pa.array(y[:, i], type=out_fields[i].type)
-            for i in range(len(out_fields))
+            pa.array(y[:, i], type=out_fields[i].type) for i in range(len(out_fields))
         ]
         return pa.StructArray.from_arrays(out_cols, fields=out_fields)
 
diff --git a/tests/differential.py b/tests/differential.py
@@ -70,7 +70,9 @@ def _arrow_type(spec: str) -> tuple[pa.DataType, bool]:
     base = spec[:-1] if nullable else spec
     if base.startswith("struct{") and base.endswith("}"):
         inner = base[len("struct{") : -1]
-        fields = [_arrow_field(*part.split(":", 1)) for part in _split_struct_fields(inner)]
+        fields = [
+            _arrow_field(*part.split(":", 1)) for part in _split_struct_fields(inner)
+        ]
         return pa.struct(fields), nullable
     if base.startswith("list[") and base.endswith("]"):
         elem_type, elem_nullable = _arrow_type(base[len("list[") : -1])
diff --git a/tests/test_diff_case.py b/tests/test_diff_case.py
@@ -95,6 +95,10 @@ def test_case_else_nullable_column_keeps_result_nullable():
     # type must stay nullable. Regression guard for infer_type ELSE nullability.
     check(
         "SELECT CASE WHEN x > 0 THEN 1 ELSE y END AS c FROM t",
-        {"t": rows({"x": "int", "y": "int?"}, [{"x": -1, "y": None}, {"x": 5, "y": 9}])},
+        {
+            "t": rows(
+                {"x": "int", "y": "int?"}, [{"x": -1, "y": None}, {"x": 5, "y": 9}]
+            )
+        },
         expect=[{"c": None}, {"c": 1}],
     )
diff --git a/tests/test_diff_composition.py b/tests/test_diff_composition.py
@@ -156,7 +156,9 @@ def test_nested_unfit_refs_with_inner_state_parity():
         "SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__"
     )
     composite = SQLTransform(t"SELECT {a}({b}(age)) AS z FROM __THIS__").fit(train)
-    _parity(composite, train)  # a(b(age)) with both carrying state -> cross-join must work
+    _parity(
+        composite, train
+    )  # a(b(age)) with both carrying state -> cross-join must work
 
 
 def test_unfit_reference_clone_contract_refits_standalone():
@@ -178,7 +180,9 @@ def test_unfit_reference_clone_contract_refits_standalone():
 
 def test_outer_aggregate_over_unfit_cascade_parity():
     train = pa.table({"age": [10.0, 20.0, 30.0, 40.0]})
-    scaler = SQLTransform("SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__")
+    scaler = SQLTransform(
+        "SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__"
+    )
     composite = SQLTransform(
         t"SELECT {scaler}(age) / MAX({scaler}(age)) OVER () AS z FROM __THIS__"
     ).fit(train)
@@ -187,7 +191,9 @@ def test_outer_aggregate_over_unfit_cascade_parity():
 
 def test_frozen_outer_over_unfit_inner_parity():
     train = pa.table({"age": [10.0, 20.0, 30.0, 40.0]})
-    inner = SQLTransform("SELECT v / MAX(v) OVER () AS d FROM __THIS__")  # unfit, has state
+    inner = SQLTransform(
+        "SELECT v / MAX(v) OVER () AS d FROM __THIS__"
+    )  # unfit, has state
     outer = SQLTransform(  # FROZEN outer
         "SELECT (v - AVG(v) OVER ()) / STDDEV(v) OVER () AS s FROM __THIS__"
     ).fit(pa.table({"v": [10.0, 20.0, 30.0, 40.0]}))
diff --git a/tests/test_diff_rust_bugs.py b/tests/test_diff_rust_bugs.py
@@ -33,7 +33,9 @@ def test_unary_minus():
 
 def test_string_concat_operator():
     check("SELECT a || '!' AS s FROM __THIS__", {_R: rows({"a": "str"}, [{"a": "hi"}])})
-    check("SELECT a || NULL AS s FROM __THIS__", {_R: rows({"a": "str"}, [{"a": "hi"}])})
+    check(
+        "SELECT a || NULL AS s FROM __THIS__", {_R: rows({"a": "str"}, [{"a": "hi"}])}
+    )
     check("SELECT a || 5 AS s FROM __THIS__", {_R: rows({"a": "str"}, [{"a": "hi"}])})
 
 
@@ -42,8 +44,14 @@ def test_coalesce_numeric_supertype():
 
 
 def test_substr_nonpositive_start():
-    check("SELECT SUBSTR(s, 0, 3) AS r FROM __THIS__", {_R: rows({"s": "str"}, [{"s": "hello"}])})
-    check("SELECT SUBSTR(s, -2, 5) AS r FROM __THIS__", {_R: rows({"s": "str"}, [{"s": "hello"}])})
+    check(
+        "SELECT SUBSTR(s, 0, 3) AS r FROM __THIS__",
+        {_R: rows({"s": "str"}, [{"s": "hello"}])},
+    )
+    check(
+        "SELECT SUBSTR(s, -2, 5) AS r FROM __THIS__",
+        {_R: rows({"s": "str"}, [{"s": "hello"}])},
+    )
 
 
 def test_nan_equals_nan():
@@ -61,7 +69,9 @@ def test_cast_string_to_bool():
 
 def test_cast_whitespace_string_to_number():
     check_both_raise("SELECT CAST(' 42 ' AS BIGINT) AS n FROM __THIS__", {_R: row(z=0)})
-    check_both_raise("SELECT CAST(' 4.5 ' AS DOUBLE) AS n FROM __THIS__", {_R: row(z=0)})
+    check_both_raise(
+        "SELECT CAST(' 4.5 ' AS DOUBLE) AS n FROM __THIS__", {_R: row(z=0)}
+    )
 
 
 def test_float_display_small_decimal_band():
diff --git a/tests/test_diff_transformer_callout.py b/tests/test_diff_transformer_callout.py
diff --git a/tests/test_diff_types.py b/tests/test_diff_types.py
diff --git a/tests/test_transformer_callout_infer.py b/tests/test_transformer_callout_infer.py
diff --git a/tests/test_transformer_case.py b/tests/test_transformer_case.py
diff --git a/tests/test_transformer_ref.py b/tests/test_transformer_ref.py
diff --git a/tests/test_transformer_udf.py b/tests/test_transformer_udf.py
diff --git a/uv.lock b/uv.lock
