fix: Preserve pandas column name attribute

narwhals/_dask/dataframe.py

@@ -12,6 +12,7 @@
 from narwhals._dask.utils import add_row_index
 from narwhals._dask.utils import evaluate_exprs
 from narwhals._pandas_like.utils import native_to_narwhals_dtype
+from narwhals._pandas_like.utils import rename_axis
 from narwhals._pandas_like.utils import select_columns_by_name
 from narwhals.typing import CompliantDataFrame
 from narwhals.typing import CompliantLazyFrame
@@ -112,7 +113,12 @@ def collect(
             from narwhals._pandas_like.dataframe import PandasLikeDataFrame
 
             return PandasLikeDataFrame(
-                result,
+                rename_axis(
+                    result,
+                    implementation=Implementation.PANDAS,
+                    backend_version=parse_version(pd),
+                    columns=self.native.columns.name,
+                ),
                 implementation=Implementation.PANDAS,
                 backend_version=parse_version(pd),
                 version=self._version,

narwhals/_pandas_like/dataframe.py

@@ -26,6 +26,7 @@
 from narwhals._pandas_like.utils import object_native_to_narwhals_dtype
 from narwhals._pandas_like.utils import pivot_table
 from narwhals._pandas_like.utils import rename
+from narwhals._pandas_like.utils import rename_axis
 from narwhals._pandas_like.utils import select_columns_by_name
 from narwhals._pandas_like.utils import set_index
 from narwhals.dependencies import is_numpy_array_1d
@@ -120,6 +121,7 @@ def __init__(
         validate_backend_version(self._implementation, self._backend_version)
         if validate_column_names:
             check_column_names_are_unique(native_dataframe.columns)
+        self._native_columns_name = native_dataframe.columns.name
 
     @classmethod
     def from_arrow(cls, data: IntoArrowTable, /, *, context: _FullContext) -> Self:
@@ -251,7 +253,12 @@ def _with_version(self: Self, version: Version) -> Self:
 
     def _with_native(self: Self, df: Any, *, validate_column_names: bool = True) -> Self:
         return self.__class__(
-            df,
+            rename_axis(
+                df,
+                implementation=self._implementation,
+                backend_version=self._backend_version,
+                columns=self._native_columns_name,
+            ),
             implementation=self._implementation,
             backend_version=self._backend_version,
             version=self._version,
@@ -633,7 +640,12 @@ def collect(
             import pandas as pd  # ignore-banned-import
 
             return PandasLikeDataFrame(
-                self.to_pandas(),
+                rename_axis(
+                    self.to_pandas(),
+                    implementation=self._implementation,
+                    backend_version=self._backend_version,
+                    columns=self._native_columns_name,
+                ),
                 implementation=Implementation.PANDAS,
                 backend_version=parse_version(pd),
                 version=self._version,

narwhals/_pandas_like/namespace.py

@@ -228,43 +228,33 @@ def concat(
     ) -> PandasLikeDataFrame:
         dfs: list[Any] = [item._native_frame for item in items]
         if how == "horizontal":
-            return PandasLikeDataFrame(
-                horizontal_concat(
-                    dfs,
-                    implementation=self._implementation,
-                    backend_version=self._backend_version,
-                ),
+            native_dataframe = horizontal_concat(
+                dfs,
                 implementation=self._implementation,
                 backend_version=self._backend_version,
-                version=self._version,
-                validate_column_names=True,
             )
-        if how == "vertical":
-            return PandasLikeDataFrame(
-                vertical_concat(
-                    dfs,
-                    implementation=self._implementation,
-                    backend_version=self._backend_version,
-                ),
+        elif how == "vertical":
+            native_dataframe = vertical_concat(
+                dfs,
                 implementation=self._implementation,
                 backend_version=self._backend_version,
-                version=self._version,
-                validate_column_names=True,
             )
-
-        if how == "diagonal":
-            return PandasLikeDataFrame(
-                diagonal_concat(
-                    dfs,
-                    implementation=self._implementation,
-                    backend_version=self._backend_version,
-                ),
+        elif how == "diagonal":
+            native_dataframe = diagonal_concat(
+                dfs,
                 implementation=self._implementation,
                 backend_version=self._backend_version,
-                version=self._version,
-                validate_column_names=True,
             )
-        raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+        return PandasLikeDataFrame(
+            native_dataframe,
+            implementation=self._implementation,
+            backend_version=self._backend_version,
+            version=self._version,
+            validate_column_names=True,
+        )
 
     def when(self: Self, predicate: PandasLikeExpr) -> PandasWhen:
         return PandasWhen.from_expr(predicate, context=self)

narwhals/_pandas_like/utils.py

@@ -794,6 +794,21 @@ def check_column_names_are_unique(columns: pd.Index[str]) -> None:
         raise DuplicateError(msg)
 
 
+def rename_axis(
+    obj: T,
+    *args: Any,
+    implementation: Implementation,
+    backend_version: tuple[int, ...],
+    **kwargs: Any,
+) -> T:
+    """Wrapper around pandas' rename_axis so that we can set `copy` based on implementation/version."""
+    if implementation is Implementation.PANDAS and (
+        backend_version >= (3,)
+    ):  # pragma: no cover
+        return obj.rename_axis(*args, **kwargs)  # type: ignore[attr-defined]
+    return obj.rename_axis(*args, **kwargs, copy=False)  # type: ignore[attr-defined]
+
+
 class PandasLikeSeriesNamespace(EagerSeriesNamespace["PandasLikeSeries", Any]):
     @property
     def implementation(self) -> Implementation:

narwhals/translate.py

@@ -488,8 +488,8 @@ def _from_native_impl(  # noqa: PLR0915
         return DataFrame(
             PandasLikeDataFrame(
                 native_object,
-                backend_version=parse_version(pd),
                 implementation=Implementation.PANDAS,
+                backend_version=parse_version(pd),
                 version=version,
                 validate_column_names=True,
             ),

tests/frame/join_test.py

@@ -10,7 +10,6 @@
 
 import narwhals as nw_main  # use nw_main in some tests for coverage
 import narwhals.stable.v1 as nw
-from narwhals.utils import Implementation
 from tests.utils import DUCKDB_VERSION
 from tests.utils import PANDAS_VERSION
 from tests.utils import POLARS_VERSION
@@ -238,11 +237,14 @@ def test_cross_join_suffix(
 
 
 def test_cross_join_non_pandas() -> None:
+    _ = pytest.importorskip("modin")
+
+    import modin.pandas as mpd
+
     data = {"antananarivo": [1, 3, 2]}
-    df = nw.from_native(pd.DataFrame(data))
-    # HACK to force testing for a non-pandas codepath
-    df._compliant_frame._implementation = Implementation.MODIN
-    result = df.join(df, how="cross")  # type: ignore[arg-type]
+    df1 = nw.from_native(mpd.DataFrame(pd.DataFrame(data)), eager_only=True)
+    df2 = nw.from_native(mpd.DataFrame(pd.DataFrame(data)), eager_only=True)
+    result = df1.join(df2, how="cross")
     expected = {
         "antananarivo": [1, 1, 1, 3, 3, 3, 2, 2, 2],
         "antananarivo_right": [1, 3, 2, 1, 3, 2, 1, 3, 2],

tests/preserve_pandas_like_columns_name_attr_test.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+import narwhals.stable.v1 as nw
+
+if TYPE_CHECKING:
+    from tests.utils import Constructor
+
+
+def test_ops_preserve_column_index_name(constructor: Constructor) -> None:
+    if not any(x in str(constructor) for x in ("pandas", "modin", "cudf", "dask")):
+        pytest.skip(
+            reason="Dataframe columns is a list and do not have a `name` like a pandas Index does"
+        )
+
+    data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8.0, 9.0]}
+    df_native = constructor(data)
+    df_native.columns.name = "foo"  # type: ignore[union-attr]
+
+    df = nw.from_native(df_native)
+
+    result = df.with_columns(b=nw.col("a") + 1, c=nw.col("a") * 2).select("c", "b")
+
+    assert result.to_native().columns.name == "foo"  # type: ignore[union-attr]
+    assert result.lazy().collect(backend="pandas").to_native().columns.name == "foo"