fix: exclude the DataFrame parameter from the supported options

Review comment on apache#42927. `exec_post_processing` calls the operation as
`operation(df, **options)`, so the first parameter takes the DataFrame
positionally. The name check accepted every parameter of the signature,
therefore an option named `df` counted as supported and reached the call,
which then raised `TypeError: pivot() got multiple values for argument 'df'`.

The behaviour is the same before this pull request, because the options went
to the operation unchanged. The check must still not call such an option
supported. It now compares against the parameters that a caller can give by
keyword: the first parameter and any positional-only parameter are excluded.

Also adds tests for the branches that the first commit left uncovered: an
option named `df`, an operation that takes `**kwargs`, and an entry that names
no operation.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: AryaKetanShCt

superset/common/query_object.py

@@ -248,8 +248,17 @@ def _drop_unsupported_options(post_proc: dict[str, Any]) -> dict[str, Any]:
         ):
             return post_proc
 
+        # `exec_post_processing` calls the operation as `operation(df, **options)`,
+        # so the first parameter receives the DataFrame positionally and can never
+        # be supplied as an option, and neither can a positional-only parameter.
+        keyword_parameters = {
+            name
+            for position, (name, parameter) in enumerate(parameters.items())
+            if position > 0 and parameter.kind is not inspect.Parameter.POSITIONAL_ONLY
+        }
+
         options = post_proc.get("options") or {}
-        unsupported = {key for key in options if key not in parameters}
+        unsupported = {key for key in options if key not in keyword_parameters}
         if not unsupported:
             return post_proc
 
@@ -263,7 +272,9 @@ def _drop_unsupported_options(post_proc: dict[str, Any]) -> dict[str, Any]:
         return {
             **post_proc,
             "options": {
-                key: value for key, value in options.items() if key in parameters
+                key: value
+                for key, value in options.items()
+                if key in keyword_parameters
             },
         }
 

tests/unit_tests/queries/query_object_test.py

@@ -21,6 +21,7 @@
 from superset.common.query_object import QueryObject
 from superset.connectors.sqla.models import SqlaTable
 from superset.models.core import Database
+from superset.utils import pandas_postprocessing
 from superset.utils.core import override_user
 
 
@@ -433,3 +434,50 @@ def test_post_processing_keeps_unknown_operation():
     assert query_object.post_processing == [
         {"operation": "does_not_exist", "options": {"a": 1}}
     ]
+
+
+def test_post_processing_drops_the_dataframe_parameter():
+    """
+    The DataFrame parameter is not an option.
+
+    `exec_post_processing` calls `operation(df, **options)`, so an option named
+    after the first parameter would raise `TypeError: pivot() got multiple
+    values for argument 'df'`.
+    """
+    query_object = QueryObject(
+        row_limit=1,
+        post_processing=[
+            {
+                "operation": "pivot",
+                "options": {"df": "malformed", "index": ["a"], "aggregates": {}},
+            }
+        ],
+    )
+
+    options = query_object.post_processing[0]["options"]
+    assert "df" not in options
+    assert options["index"] == ["a"]
+
+
+def test_post_processing_keeps_options_of_a_variadic_operation():
+    """An operation that accepts `**kwargs` accepts every option."""
+
+    def variadic(df, **kwargs):
+        return df
+
+    post_processing = [{"operation": "variadic", "options": {"anything": 1}}]
+    with patch.object(pandas_postprocessing, "variadic", variadic, create=True):
+        query_object = QueryObject(row_limit=1, post_processing=post_processing)
+
+    assert query_object.post_processing == post_processing
+
+
+def test_post_processing_keeps_an_entry_without_an_operation():
+    """
+    An entry that names no operation is kept, so that `exec_post_processing`
+    reports it as an `InvalidPostProcessingError`.
+    """
+    post_processing = [{"options": {"a": 1}}]
+    query_object = QueryObject(row_limit=1, post_processing=post_processing)
+
+    assert query_object.post_processing == post_processing