docs: strip implementation jargon from Expr pickle docstrings

Previous wording for `Expr.to_bytes`, `Expr.__reduce__`, and the
`datafusion.ipc` module header referenced ``PythonLogicalCodec`` and
``cloudpickle`` to explain what survives the wire. Neither name is
importable from Python and the mechanism is irrelevant to the end
user — only the resulting contract matters.

Reword each docstring to describe the user-facing guarantee directly:

* Python scalar UDFs travel inside the pickle / serialized blob, no
  pre-registration needed on the receiver.
* Aggregate UDFs, window UDFs, and FFI-capsule UDFs travel by name
  only and require the receiver to have them registered (typically
  via `set_worker_ctx`).

The implementation can change underneath without invalidating these
docs.

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

Author: timsaucer

python/datafusion/expr.py

@@ -436,9 +436,9 @@ def variant_name(self) -> str:
     def to_bytes(self, ctx: SessionContext | None = None) -> bytes:
         """Serialize this expression to protobuf bytes.
 
-        Python scalar UDFs are cloudpickled inline by
-        :class:`PythonLogicalCodec`, so the returned blob is
-        self-contained for scalar UDFs. Aggregate / window / FFI UDFs
+        Python scalar UDFs are inlined into the returned bytes — the
+        receiver does not need to pre-register them. Aggregate UDFs,
+        window UDFs, and UDFs imported via the FFI capsule protocol
         are stored by name only; the receiver must have them
         registered.
 
@@ -467,13 +467,14 @@ def from_bytes(cls, buf: bytes, ctx: SessionContext | None = None) -> Expr:
     def __reduce__(self) -> tuple:
         """Pickle protocol hook.
 
-        :class:`PythonLogicalCodec` cloudpickles referenced Python
-        scalar UDFs directly into the proto wire format, so the
-        returned blob is self-contained. On unpickle the bytes are
-        decoded against the worker context set via
+        Python scalar UDFs referenced by the expression are inlined
+        into the pickle blob, so the receiver does not need to
+        pre-register them. On unpickle the bytes are decoded against
+        the worker context set via
         :func:`datafusion.ipc.set_worker_ctx` (or a fresh
-        :class:`SessionContext` if none) for any remaining
-        registry-resolved references.
+        :class:`SessionContext` if none) for any registry-resolved
+        references — aggregate UDFs, window UDFs, UDFs imported via
+        the FFI capsule protocol.
         """
         return (Expr._reconstruct, (self.to_bytes(),))
 

python/datafusion/ipc.py

@@ -31,12 +31,12 @@
 ...     # register Rust-backed UDFs / aggregates / window functions here
 ...     set_worker_ctx(ctx)
 
-Python scalar UDFs do not need pre-registration: their definitions are
-cloudpickled into the proto wire format by ``PythonLogicalCodec`` and
-reconstructed on the receiver automatically. The worker context is only
-needed when the expression references aggregate / window UDFs, table
-providers, or Rust-side function registrations the receiver wouldn't
-otherwise have.
+Python scalar UDFs do not need pre-registration: their definitions
+travel inside the pickled expression and are reconstructed on the
+receiver automatically. The worker context is only needed when the
+expression references aggregate UDFs, window UDFs, table providers,
+or UDFs imported via the FFI capsule protocol — anything the
+receiver would otherwise resolve from its registered functions.
 """
 
 from __future__ import annotations