Merge branch 'main' into feat/bundle-functions

Resolves conflicts with #1759, which hardened the extension API for 55.0.0:

- context.py: drop the local PhysicalOptimizerRuleExportable (moved to
  datafusion.extensions) and route the bundle protocol isinstance checks in
  _collect_contributions and the planner-hook filter through the private
  _extensions alias, so the protocols stay type-only in datafusion.context.
- extensions.py: keep _COMPONENT_NOUNS and apply kw_only=True to
  SessionExtensionComponents.
- ffi-internals.md: keep this branch's four steps, where functions are resolved
  in step 3 and the planner is imported as each hook returns, so the commit
  itself cannot fail. Take main's carve-out for hook-side writes and the
  empty-call rebind skip. Drop main's note that the commit re-imports the
  capsule, which no longer holds here.
- bundles.md: keep the collisions section and drop the shorter duplicate of
  the "Declaring a component" paragraph that auto-merge introduced.

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

Author: timsaucer

.ai/skills/check-upstream/SKILL.md

@@ -146,6 +146,7 @@ The user may specify an area via `$ARGUMENTS`. If no area is specified or "all"
 - `show_limit` — already covered by `DataFrame.show()`, which provides the same functionality with a simpler API
 - `with_param_values` — already covered by the `param_values` argument on `SessionContext.sql()`, which accomplishes the same thing more robustly
 - `union_by_name_distinct` — already covered by `DataFrame.union_by_name(distinct=True)`, which provides a more Pythonic API
+- `to_string` — `str(df)` is the Pythonic way to get a string and already goes through `__repr__` and the configurable formatter. A separate `to_string()` would either duplicate `str(df)` or render every row through a different path (session `datafusion.format.*` options, no formatter), giving a third text rendering alongside `repr` and `show()`
 
 **How to check:**
 1. Fetch the upstream DataFrame documentation page listing all methods

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ name: CI
 
 on:
   pull_request:
-    branches: ["main"]
+    branches: ["main", "branch-*"]
 
 concurrency:
   group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}

.github/workflows/release.yml

@@ -27,6 +27,7 @@ on:
   push:
     branches:
       - "main"
+      - "branch-*"
     tags:
       - "*-rc*"      # Release candidates (e.g., 45.0.0-rc1)
       - "[0-9]+.*"   # Release tags (e.g., 45.0.0)

Cargo.lock

@@ -16,7 +16,7 @@
 # under the License.
 
 [workspace.package]
-version = "54.0.0"
+version = "55.0.0"
 homepage = "https://datafusion.apache.org/python"
 repository = "https://github.com/apache/datafusion-python"
 authors = ["Apache DataFusion <dev@datafusion.apache.org>"]
@@ -69,7 +69,7 @@ log = "0.4.29"
 parking_lot = "0.12"
 prost-types = "0.14.3"                                                # keep in line with `datafusion-substrait`
 pyo3-build-config = "0.29"
-datafusion-python-util = { path = "crates/util", version = "54.0.0" }
+datafusion-python-util = { path = "crates/util", version = "55.0.0" }
 
 [profile.release]
 lto = "thin"

Cargo.toml

@@ -844,13 +844,24 @@ impl PyDataFrame {
     }
 
     /// Print the query plan
-    #[pyo3(signature = (verbose=false, analyze=false, format=None))]
+    #[pyo3(signature = (
+        verbose=false,
+        analyze=false,
+        format=None,
+        show_statistics=None,
+        analyze_level=None,
+        analyze_categories=None
+    ))]
+    #[allow(clippy::too_many_arguments)]
     fn explain(
         &self,
         py: Python,
         verbose: bool,
         analyze: bool,
         format: Option<&str>,
+        show_statistics: Option<bool>,
+        analyze_level: Option<&str>,
+        analyze_categories: Option<Vec<String>>,
     ) -> PyDataFusionResult<()> {
         let explain_format = match format {
             Some(f) => f
@@ -860,10 +871,24 @@ impl PyDataFrame {
                 })?,
             None => datafusion::common::format::ExplainFormat::Indent,
         };
+        let analyze_level = analyze_level
+            .map(|l| l.parse::<datafusion::common::format::MetricType>())
+            .transpose()?;
+        let analyze_categories = analyze_categories
+            .map(|cats| {
+                cats.iter()
+                    .map(|c| c.parse::<datafusion::common::format::MetricCategory>())
+                    .collect::<datafusion::common::Result<Vec<_>>>()
+                    .map(datafusion::common::format::ExplainAnalyzeCategories::Only)
+            })
+            .transpose()?;
         let opts = datafusion::logical_expr::ExplainOption::default()
             .with_verbose(verbose)
             .with_analyze(analyze)
-            .with_format(explain_format);
+            .with_format(explain_format)
+            .with_show_statistics(show_statistics)
+            .with_analyze_level(analyze_level)
+            .with_analyze_categories(analyze_categories);
         let df = self.df.as_ref().clone().explain_with_options(opts)?;
         print_dataframe(py, df)
     }
@@ -1320,6 +1345,26 @@ impl PyDataFrame {
         let df = self.df.as_ref().fill_null(&scalar_value.0, &cols)?;
         Ok(Self::new(df))
     }
+
+    /// Fill NaN values with a specified value for specific floating-point columns
+    #[pyo3(signature = (value, columns=None))]
+    fn fill_nan(
+        &self,
+        value: Py<PyAny>,
+        columns: Option<Vec<PyBackedStr>>,
+        py: Python,
+    ) -> PyDataFusionResult<Self> {
+        let scalar_value: PyScalarValue = value.extract(py)?;
+
+        let cols = match columns {
+            Some(col_names) => col_names.iter().map(|c| c.to_string()).collect(),
+            None => Vec::new(), // Empty vector means fill NaN for all columns
+        };
+
+        let cols = cols.iter().map(String::as_str).collect::<Vec<_>>();
+        let df = self.df.as_ref().fill_nan(&scalar_value.0, &cols)?;
+        Ok(Self::new(df))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]