revert: undo last commit

Moved to #2368

Author: dangotbanned

narwhals/_pandas_like/dataframe.py

@@ -21,6 +21,7 @@
 from narwhals._pandas_like.utils import check_column_names_are_unique
 from narwhals._pandas_like.utils import convert_str_slice_to_int_slice
 from narwhals._pandas_like.utils import get_dtype_backend
+from narwhals._pandas_like.utils import horizontal_concat
 from narwhals._pandas_like.utils import native_to_narwhals_dtype
 from narwhals._pandas_like.utils import object_native_to_narwhals_dtype
 from narwhals._pandas_like.utils import pivot_table
@@ -510,8 +511,11 @@ def select(self: PandasLikeDataFrame, *exprs: PandasLikeExpr) -> PandasLikeDataF
             # return empty dataframe, like Polars does
             return self._with_native(self.native.__class__(), validate_column_names=False)
         new_series = align_series_full_broadcast(*new_series)
-        namespace = self.__narwhals_namespace__()
-        df = namespace._horizontal_concat([s.native for s in new_series])
+        df = horizontal_concat(
+            [s.native for s in new_series],
+            implementation=self._implementation,
+            backend_version=self._backend_version,
+        )
         return self._with_native(df, validate_column_names=True)
 
     def drop_nulls(
@@ -534,7 +538,13 @@ def with_row_index(self: Self, name: str) -> Self:
         row_index = namespace._series.from_iterable(
             range(len(frame)), context=self, index=frame.index
         ).alias(name)
-        return self._with_native(namespace._horizontal_concat([row_index.native, frame]))
+        return self._with_native(
+            horizontal_concat(
+                [row_index.native, frame],
+                implementation=self._implementation,
+                backend_version=self._backend_version,
+            )
+        )
 
     def row(self: Self, index: int) -> tuple[Any, ...]:
         return tuple(x for x in self.native.iloc[index])
@@ -568,8 +578,11 @@ def with_columns(
                 series = self.native[name]
             to_concat.append(series)
         to_concat.extend(self._extract_comparand(s) for s in name_columns.values())
-        namespace = self.__narwhals_namespace__()
-        df = namespace._horizontal_concat(to_concat)
+        df = horizontal_concat(
+            to_concat,
+            implementation=self._implementation,
+            backend_version=self._backend_version,
+        )
         return self._with_native(df, validate_column_names=False)
 
     def rename(self: Self, mapping: Mapping[str, str]) -> Self:

narwhals/_pandas_like/group_by.py

@@ -11,6 +11,7 @@
 
 from narwhals._compliant import EagerGroupBy
 from narwhals._expression_parsing import evaluate_output_names_and_aliases
+from narwhals._pandas_like.utils import horizontal_concat
 from narwhals._pandas_like.utils import select_columns_by_name
 from narwhals._pandas_like.utils import set_columns
 from narwhals.utils import find_stacklevel
@@ -232,8 +233,11 @@ def agg(self: Self, *exprs: PandasLikeExpr) -> PandasLikeDataFrame:  # noqa: PLR
                             pass
                     msg = f"Expected unique output names, got:{msg}"
                     raise ValueError(msg)
-                namespace = self.compliant.__narwhals_namespace__()
-                result = namespace._horizontal_concat(result_aggs)
+                result = horizontal_concat(
+                    dfs=result_aggs,
+                    implementation=implementation,
+                    backend_version=backend_version,
+                )
             else:
                 # No aggregation provided
                 result = self.compliant.__native_namespace__().DataFrame(

narwhals/_pandas_like/namespace.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
 import operator
-import warnings
 from functools import reduce
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Iterable
-from typing import Sequence
-from typing import TypeVar
 
 from narwhals._compliant import CompliantThen
 from narwhals._compliant import EagerNamespace
@@ -20,6 +17,7 @@
 from narwhals._pandas_like.series import PandasLikeSeries
 from narwhals._pandas_like.utils import align_series_full_broadcast
 from narwhals._pandas_like.utils import diagonal_concat
+from narwhals._pandas_like.utils import horizontal_concat
 from narwhals._pandas_like.utils import vertical_concat
 from narwhals.utils import import_dtypes_module
 
@@ -32,8 +30,6 @@
     from narwhals.utils import Implementation
     from narwhals.utils import Version
 
-    NDFrameT = TypeVar("NDFrameT", "pd.DataFrame", "pd.Series[Any]")
-
 
 class PandasLikeNamespace(
     EagerNamespace[
@@ -227,27 +223,16 @@ def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
             context=self,
         )
 
-    def _horizontal_concat(self, dfs: Sequence[NDFrameT], /) -> NDFrameT:
-        """Concatenate (native) DataFrames horizontally."""
-        concat = self._implementation.to_native_namespace().concat
-        if self._implementation.is_cudf():
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    message="The behavior of array concatenation with empty entries is deprecated",
-                    category=FutureWarning,
-                )
-                return concat(dfs, axis=1)
-        elif self._implementation.is_pandas() and self._backend_version < (3,):
-            return concat(dfs, axis=1, copy=False)
-        return concat(dfs, axis=1)
-
     def concat(
         self, items: Iterable[PandasLikeDataFrame], *, how: ConcatMethod
     ) -> PandasLikeDataFrame:
         dfs: list[Any] = [item._native_frame for item in items]
         if how == "horizontal":
-            native_dataframe = self._horizontal_concat(dfs)
+            native_dataframe = horizontal_concat(
+                dfs,
+                implementation=self._implementation,
+                backend_version=self._backend_version,
+            )
         elif how == "vertical":
             native_dataframe = vertical_concat(
                 dfs,

narwhals/_pandas_like/utils.py

@@ -2,6 +2,7 @@
 
 import functools
 import re
+import warnings
 from contextlib import suppress
 from typing import TYPE_CHECKING
 from typing import Any
@@ -129,6 +130,35 @@ def align_and_extract_native(
     return lhs.native, rhs
 
 
+def horizontal_concat(
+    dfs: list[Any], *, implementation: Implementation, backend_version: tuple[int, ...]
+) -> Any:
+    """Concatenate (native) DataFrames horizontally.
+
+    Should be in namespace.
+    """
+    if implementation is Implementation.CUDF:
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message="The behavior of array concatenation with empty entries is deprecated",
+                category=FutureWarning,
+            )
+            return implementation.to_native_namespace().concat(dfs, axis=1)
+
+    if implementation.is_pandas_like():
+        extra_kwargs = (
+            {"copy": False}
+            if implementation is Implementation.PANDAS and backend_version < (3,)
+            else {}
+        )
+        return implementation.to_native_namespace().concat(dfs, axis=1, **extra_kwargs)
+
+    else:  # pragma: no cover
+        msg = f"Expected pandas-like implementation ({PANDAS_LIKE_IMPLEMENTATION}), found {implementation}"
+        raise TypeError(msg)
+
+
 def vertical_concat(
     dfs: list[Any], *, implementation: Implementation, backend_version: tuple[int, ...]
 ) -> Any: