refactor(ctx): make with_python_udf_inlining enabled keyword-only

`ctx.with_python_udf_inlining(True)` and
`ctx.with_python_udf_inlining(False)` read identically at the call site
— a bare positional `True` / `False` does not convey which direction the
toggle moves. Forcing `enabled=` at the call site disambiguates:
`with_python_udf_inlining(enabled=False)` is unambiguously the
opt-out form.

The Rust constructor stays positional (internal API); only the public
Python wrapper changes signature. All in-tree callers (tests, docs,
FFI example test) already used or now use the keyword form.

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

Author: timsaucer

docs/source/user-guide/io/distributing_work.rst

@@ -170,7 +170,7 @@ worker slots are unused.
    To opt into the strict format,
    :py:func:`~datafusion.ipc.set_sender_ctx`
    with a session built via
-   :py:meth:`SessionContext.with_python_udf_inlining(False)
+   :py:meth:`SessionContext.with_python_udf_inlining(enabled=False)
    <datafusion.SessionContext.with_python_udf_inlining>`.
 
 2. *Worker side — what registrations does decode need?* For built-ins
@@ -265,7 +265,7 @@ Disabling Python UDF inlining
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 For a stricter wire format, call
-:py:meth:`SessionContext.with_python_udf_inlining(False)
+:py:meth:`SessionContext.with_python_udf_inlining(enabled=False)
 <datafusion.SessionContext.with_python_udf_inlining>` on the session
 producing or consuming the bytes. With inlining disabled, Python
 UDFs travel by name only — the same way FFI-capsule UDFs do — and
@@ -295,7 +295,7 @@ session as the driver's *sender context*:
     from datafusion import SessionContext
     from datafusion.ipc import set_sender_ctx
 
-    set_sender_ctx(SessionContext().with_python_udf_inlining(False))
+    set_sender_ctx(SessionContext().with_python_udf_inlining(enabled=False))
     # Every subsequent pickle.dumps(expr) on this thread encodes
     # without inlining the Python callable.
 

python/datafusion/context.py

@@ -1770,9 +1770,15 @@ def with_physical_extension_codec(self, codec: Any) -> SessionContext:
         new.ctx = new_internal
         return new
 
-    def with_python_udf_inlining(self, enabled: bool) -> SessionContext:
+    def with_python_udf_inlining(self, *, enabled: bool) -> SessionContext:
         """Toggle inline encoding of Python-defined UDFs on this session.
 
+        ``enabled`` is keyword-only:
+        ``with_python_udf_inlining(enabled=False)`` reads at the call
+        site as the inverse of
+        ``with_python_udf_inlining(enabled=True)``, where a positional
+        ``True`` / ``False`` would not.
+
         When ``True`` (the default), Python scalar, aggregate, and window
         UDFs travel inside the serialized expression and are
         reconstructed on the receiver without pre-registration.

python/datafusion/ipc.py

@@ -49,7 +49,7 @@ def init_worker():
     from datafusion import SessionContext
     from datafusion.ipc import set_sender_ctx
 
-    driver_ctx = SessionContext().with_python_udf_inlining(False)
+    driver_ctx = SessionContext().with_python_udf_inlining(enabled=False)
     set_sender_ctx(driver_ctx)
     pickle.dumps(expr)  # encoded with inlining disabled
 

python/tests/test_pickle_expr.py

@@ -247,7 +247,7 @@ def test_window_udf_decodes_via_pickle_with_no_worker_ctx(self):
 
 
 class TestPythonUdfInliningToggle:
-    """`SessionContext.with_python_udf_inlining(False)` opts out of
+    """`SessionContext.with_python_udf_inlining(enabled=False)` opts out of
     inline Python UDF encoding for both encode and decode paths."""
 
     def _build_double_udf(self):
@@ -263,7 +263,7 @@ def test_strict_encoder_emits_smaller_blob(self):
         """Strict mode skips cloudpickle of the Python callable, so the
         encoded bytes are dramatically smaller than the inline form."""
         ctx_inline = SessionContext()
-        ctx_strict = ctx_inline.with_python_udf_inlining(False)
+        ctx_strict = ctx_inline.with_python_udf_inlining(enabled=False)
         u = self._build_double_udf()
         e = u(col("a"))
 
@@ -276,11 +276,11 @@ def test_strict_roundtrip_via_registry(self):
         """When both sender and receiver disable inlining, the UDF
         travels by name only and the receiver resolves it from its
         registered functions."""
-        strict_sender = SessionContext().with_python_udf_inlining(False)
+        strict_sender = SessionContext().with_python_udf_inlining(enabled=False)
         u = self._build_double_udf()
         blob = u(col("a")).to_bytes(strict_sender)
 
-        receiver = SessionContext().with_python_udf_inlining(False)
+        receiver = SessionContext().with_python_udf_inlining(enabled=False)
         receiver.register_udf(u)
         restored = Expr.from_bytes(blob, ctx=receiver)
         assert "double" in restored.canonical_name()
@@ -292,7 +292,7 @@ def test_strict_decoder_refuses_inline_payload(self):
         u = self._build_double_udf()
         blob = u(col("a")).to_bytes(sender)
 
-        strict_receiver = SessionContext().with_python_udf_inlining(False)
+        strict_receiver = SessionContext().with_python_udf_inlining(enabled=False)
         strict_receiver.register_udf(u)
         # `RuntimeError` (not bare `Exception`): the codec refusal is
         # surfaced through `parse_expr` → `PyRuntimeError`. Tightening
@@ -314,7 +314,7 @@ def test_sender_ctx_propagates_through_pickle(self):
 
         blob_default = pickle.dumps(e)
 
-        strict_sender = SessionContext().with_python_udf_inlining(False)
+        strict_sender = SessionContext().with_python_udf_inlining(enabled=False)
         set_sender_ctx(strict_sender)
         try:
             blob_strict = pickle.dumps(e)
@@ -333,14 +333,14 @@ def test_sender_ctx_strict_roundtrip_via_pickle(self):
         u = self._build_double_udf()
         e = u(col("a"))
 
-        strict_sender = SessionContext().with_python_udf_inlining(False)
+        strict_sender = SessionContext().with_python_udf_inlining(enabled=False)
         set_sender_ctx(strict_sender)
         try:
             blob = pickle.dumps(e)
         finally:
             clear_sender_ctx()
 
-        worker = SessionContext().with_python_udf_inlining(False)
+        worker = SessionContext().with_python_udf_inlining(enabled=False)
         worker.register_udf(u)
         set_worker_ctx(worker)
         try:
@@ -358,7 +358,7 @@ def test_sender_ctx_strict_pickle_accepted_by_inline_worker_with_registry(self):
         u = self._build_double_udf()
         e = u(col("a"))
 
-        strict_sender = SessionContext().with_python_udf_inlining(False)
+        strict_sender = SessionContext().with_python_udf_inlining(enabled=False)
         set_sender_ctx(strict_sender)
         try:
             blob = pickle.dumps(e)