[ci] apply automatic fixes

Signed-off-by: feldera-bot <feldera-bot@feldera.com>
feldera · wilmaontherun · Mar 16, 2026 · Mar 16, 2026 · Mar 19, 2026 · Mar 19, 2026
commit bb1b24c5488b400eda94b387e48b14d37ab661d3
diff --git a/python/felderize/spark/cli.py b/python/felderize/spark/cli.py
@@ -22,14 +22,20 @@ def cli():
 @click.option("--validate", is_flag=True, help="Validate against Feldera instance")
 @click.option("--json-output", is_flag=True, help="Output as JSON")
 @click.option("--no-docs", is_flag=True, help="Disable Feldera doc inclusion in prompt")
-def translate(schema_file: str, query_file: str, validate: bool, json_output: bool, no_docs: bool):
+def translate(
+    schema_file: str, query_file: str, validate: bool, json_output: bool, no_docs: bool
+):
     """Translate a single Spark SQL schema + query pair to Feldera SQL."""
     config = Config.from_env()
     schema_sql = Path(schema_file).read_text()
     query_sql = Path(query_file).read_text()
 
     result = translate_spark_to_feldera(
-        schema_sql, query_sql, config, validate=validate, include_docs=not no_docs,
+        schema_sql,
+        query_sql,
+        config,
+        validate=validate,
+        include_docs=not no_docs,
     )
 
     if json_output:
@@ -70,7 +76,11 @@ def batch(data_dir: str, validate: bool, output_dir: str | None, no_docs: bool):
 
         click.echo(f"Translating {name}...", err=True)
         result = translate_spark_to_feldera(
-            schema_sql, query_sql, config, validate=validate, include_docs=not no_docs,
+            schema_sql,
+            query_sql,
+            config,
+            validate=validate,
+            include_docs=not no_docs,
         )
         results[name] = result.to_dict()
 
@@ -98,7 +108,11 @@ def batch(data_dir: str, validate: bool, output_dir: str | None, no_docs: bool):
 
 @cli.command()
 @click.argument("name", required=False)
-@click.option("--validate/--no-validate", default=True, help="Validate against Feldera instance (default: on)")
+@click.option(
+    "--validate/--no-validate",
+    default=True,
+    help="Validate against Feldera instance (default: on)",
+)
 @click.option("--json-output", is_flag=True, help="Output as JSON")
 @click.option("--no-docs", is_flag=True, help="Disable Feldera doc inclusion in prompt")
 def example(name: str | None, validate: bool, json_output: bool, no_docs: bool):
@@ -124,7 +138,7 @@ def example(name: str | None, validate: bool, json_output: bool, no_docs: bool):
         for ex_name, (sf, qf) in pairs.items():
             schema_preview = sf.read_text().strip().split("\n")[0]
             click.echo(f"  {ex_name:20s} {schema_preview}")
-        click.echo(f"\nRun one with: felderize example <name>")
+        click.echo("\nRun one with: felderize example <name>")
         return
 
     if name not in pairs:
@@ -143,7 +157,11 @@ def example(name: str | None, validate: bool, json_output: bool, no_docs: bool):
 
     config = Config.from_env()
     result = translate_spark_to_feldera(
-        schema_sql, query_sql, config, validate=validate, include_docs=not no_docs,
+        schema_sql,
+        query_sql,
+        config,
+        validate=validate,
+        include_docs=not no_docs,
     )
 
     if json_output:

diff --git a/python/felderize/spark/docs.py b/python/felderize/spark/docs.py
@@ -10,40 +10,88 @@
 _CATEGORIES: dict[str, list[str]] = {
     "types": [],  # Always matched
     "string": [
-        r"\bUPPER\b", r"\bLOWER\b", r"\bTRIM\b", r"\bCONCAT\b",
-        r"\bSUBSTRING\b", r"\bREPLACE\b", r"\bLIKE\b", r"\bREGEXP\b",
-        r"\bLENGTH\b", r"\bINITCAP\b", r"\bREVERSE\b", r"\bREPEAT\b",
-        r"\bSPLIT\b", r"\bLPAD\b", r"\bRPAD\b",
+        r"\bUPPER\b",
+        r"\bLOWER\b",
+        r"\bTRIM\b",
+        r"\bCONCAT\b",
+        r"\bSUBSTRING\b",
+        r"\bREPLACE\b",
+        r"\bLIKE\b",
+        r"\bREGEXP\b",
+        r"\bLENGTH\b",
+        r"\bINITCAP\b",
+        r"\bREVERSE\b",
+        r"\bREPEAT\b",
+        r"\bSPLIT\b",
+        r"\bLPAD\b",
+        r"\bRPAD\b",
     ],
     "datetime": [
-        r"\bDATE\b", r"\bTIMESTAMP\b", r"\bINTERVAL\b", r"\bYEAR\b",
-        r"\bMONTH\b", r"\bDAY\b", r"\bHOUR\b", r"\bEXTRACT\b",
-        r"\bDATE_ADD\b", r"\bDATE_SUB\b", r"\bDATEDIFF\b",
-        r"\bDATE_TRUNC\b", r"\bCURRENT_DATE\b", r"\bCURRENT_TIMESTAMP\b",
+        r"\bDATE\b",
+        r"\bTIMESTAMP\b",
+        r"\bINTERVAL\b",
+        r"\bYEAR\b",
+        r"\bMONTH\b",
+        r"\bDAY\b",
+        r"\bHOUR\b",
+        r"\bEXTRACT\b",
+        r"\bDATE_ADD\b",
+        r"\bDATE_SUB\b",
+        r"\bDATEDIFF\b",
+        r"\bDATE_TRUNC\b",
+        r"\bCURRENT_DATE\b",
+        r"\bCURRENT_TIMESTAMP\b",
     ],
     "json": [
-        r"\bJSON\b", r"\bPARSE_JSON\b", r"\bVARIANT\b",
-        r"\bget_json_object\b", r"\bfrom_json\b", r"\bjson_tuple\b",
+        r"\bJSON\b",
+        r"\bPARSE_JSON\b",
+        r"\bVARIANT\b",
+        r"\bget_json_object\b",
+        r"\bfrom_json\b",
+        r"\bjson_tuple\b",
         r"\bTO_JSON\b",
     ],
     "aggregates": [
-        r"\bCOUNT\b", r"\bSUM\b", r"\bAVG\b", r"\bGROUP\s+BY\b",
-        r"\bHAVING\b", r"\bOVER\s*\(", r"\bROW_NUMBER\b", r"\bRANK\b",
-        r"\bLAG\b", r"\bLEAD\b", r"\bWINDOW\b",
+        r"\bCOUNT\b",
+        r"\bSUM\b",
+        r"\bAVG\b",
+        r"\bGROUP\s+BY\b",
+        r"\bHAVING\b",
+        r"\bOVER\s*\(",
+        r"\bROW_NUMBER\b",
+        r"\bRANK\b",
+        r"\bLAG\b",
+        r"\bLEAD\b",
+        r"\bWINDOW\b",
     ],
     "array": [
-        r"\bARRAY\b", r"\bEXPLODE\b", r"\bUNNEST\b",
-        r"\barray_contains\b", r"\bsort_array\b", r"\barray_distinct\b",
-        r"\bCARDINALITY\b", r"\bsize\s*\(",
+        r"\bARRAY\b",
+        r"\bEXPLODE\b",
+        r"\bUNNEST\b",
+        r"\barray_contains\b",
+        r"\bsort_array\b",
+        r"\barray_distinct\b",
+        r"\bCARDINALITY\b",
+        r"\bsize\s*\(",
     ],
     "map": [r"\bMAP\s*<", r"\bMAP\s*\(", r"\bmap_keys\b", r"\bmap_values\b"],
     "decimal": [
-        r"\bDECIMAL\b", r"\bNUMERIC\b", r"\bROUND\b", r"\bCEIL\b",
-        r"\bFLOOR\b", r"\bTRUNCATE\b",
+        r"\bDECIMAL\b",
+        r"\bNUMERIC\b",
+        r"\bROUND\b",
+        r"\bCEIL\b",
+        r"\bFLOOR\b",
+        r"\bTRUNCATE\b",
     ],
     "float": [
-        r"\bFLOAT\b", r"\bDOUBLE\b", r"\bPOWER\b", r"\bSQRT\b",
-        r"\bLOG\b", r"\bLN\b", r"\bSIN\b", r"\bCOS\b",
+        r"\bFLOAT\b",
+        r"\bDOUBLE\b",
+        r"\bPOWER\b",
+        r"\bSQRT\b",
+        r"\bLOG\b",
+        r"\bLN\b",
+        r"\bSIN\b",
+        r"\bCOS\b",
     ],
     "casts": [r"\bCAST\s*\(", r"::"],
     "comparisons": [r"\bBETWEEN\b", r"\bCASE\s+WHEN\b", r"\bCOALESCE\b", r"\bNULLIF\b"],

diff --git a/python/felderize/spark/skills.py b/python/felderize/spark/skills.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 from pathlib import Path
 
 import yaml
@@ -77,8 +76,7 @@ def build_system_prompt(
             prompt += (
                 "\n\n## Validated Translation Examples\n\n"
                 "These examples were validated against the Feldera compiler. "
-                "Follow the same patterns.\n\n"
-                + examples_text
+                "Follow the same patterns.\n\n" + examples_text
             )
         if with_docs:
             docs_text = load_docs(spark_sql, docs_dir)

diff --git a/python/felderize/spark/translator.py b/python/felderize/spark/translator.py
@@ -127,14 +127,22 @@ def _translate_once(
         raw = client.translate(system_prompt, repair_prompt)
         try:
             data = _parse_response(raw)
-            result.feldera_schema = _as_str(data.get("feldera_schema", result.feldera_schema))
-            result.feldera_query = _as_str(data.get("feldera_query", result.feldera_query))
+            result.feldera_schema = _as_str(
+                data.get("feldera_schema", result.feldera_schema)
+            )
+            result.feldera_query = _as_str(
+                data.get("feldera_query", result.feldera_query)
+            )
             result.unsupported = _as_list(data.get("unsupported", result.unsupported))
             result.warnings = _as_list(data.get("warnings", result.warnings))
-            result.explanations = _as_list(data.get("explanations", result.explanations))
+            result.explanations = _as_list(
+                data.get("explanations", result.explanations)
+            )
             full_sql = result.feldera_schema + "\n\n" + result.feldera_query
         except (json.JSONDecodeError, KeyError):
-            result.warnings.append(f"Repair attempt {attempt + 1} produced invalid JSON")
+            result.warnings.append(
+                f"Repair attempt {attempt + 1} produced invalid JSON"
+            )
 
     # Final validation after all retries
     errors = validate_sql(full_sql, config.feldera_compiler or None)
@@ -143,7 +151,9 @@ def _translate_once(
         result.status = Status.UNSUPPORTED if result.unsupported else Status.SUCCESS
     else:
         result.status = Status.ERROR
-        result.warnings.extend([f"Still failing after {max_retries} repairs: {e}" for e in errors])
+        result.warnings.extend(
+            [f"Still failing after {max_retries} repairs: {e}" for e in errors]
+        )
 
     return result
 
@@ -164,21 +174,38 @@ def translate_spark_to_feldera(
 
     # First pass: skills + examples only (no docs)
     system_prompt = build_system_prompt(
-        skills_dir, docs_dir=docs_dir_path, spark_sql=combined_sql, with_docs=False,
+        skills_dir,
+        docs_dir=docs_dir_path,
+        spark_sql=combined_sql,
+        with_docs=False,
     )
     result = _translate_once(
-        schema_sql, query_sql, config, client, system_prompt, validate, max_retries,
+        schema_sql,
+        query_sql,
+        config,
+        client,
+        system_prompt,
+        validate,
+        max_retries,
     )
 
     # If first pass failed and docs are enabled, retry with docs
     if result.status == Status.ERROR and include_docs:
         print("Retrying with Feldera docs...", file=sys.stderr)
         system_prompt_with_docs = build_system_prompt(
-            skills_dir, docs_dir=docs_dir_path, spark_sql=combined_sql, with_docs=True,
+            skills_dir,
+            docs_dir=docs_dir_path,
+            spark_sql=combined_sql,
+            with_docs=True,
         )
         result = _translate_once(
-            schema_sql, query_sql, config, client, system_prompt_with_docs,
-            validate, max_retries,
+            schema_sql,
+            query_sql,
+            config,
+            client,
+            system_prompt_with_docs,
+            validate,
+            max_retries,
         )
         if result.status != Status.ERROR:
             result.warnings.append("Resolved with docs fallback")