feat: adds EagerExprNameNamespace

Didn't realise until now that both backends did the same thing

Author: dangotbanned

narwhals/_arrow/expr.py

@@ -8,7 +8,6 @@
 
 import pyarrow.compute as pc
 
-from narwhals._arrow.expr_name import ArrowExprNameNamespace
 from narwhals._arrow.series import ArrowSeries
 from narwhals._compliant import EagerExpr
 from narwhals._expression_parsing import ExprKind
@@ -263,7 +262,3 @@ def rank(
         return self._reuse_series("rank", method=method, descending=descending)
 
     ewm_mean = not_implemented()
-
-    @property
-    def name(self: Self) -> ArrowExprNameNamespace:
-        return ArrowExprNameNamespace(self)

narwhals/_arrow/expr_name.py

@@ -12,7 +12,6 @@
 import pyarrow as pa
 import pyarrow.compute as pc
 
-from narwhals.utils import _ExprNamespace
 from narwhals.utils import _SeriesNamespace
 from narwhals.utils import import_dtypes_module
 from narwhals.utils import isinstance_or_issubclass
@@ -24,7 +23,6 @@
     from typing_extensions import TypeAlias
     from typing_extensions import TypeIs
 
-    from narwhals._arrow.expr import ArrowExpr
     from narwhals._arrow.series import ArrowSeries
     from narwhals._arrow.typing import ArrowArray
     from narwhals._arrow.typing import ArrowChunkedArray
@@ -548,8 +546,3 @@ def pad_series(
 class ArrowSeriesNamespace(_SeriesNamespace["ArrowSeries", "ArrowChunkedArray"]):
     def __init__(self: Self, series: ArrowSeries, /) -> None:
         self._compliant_series = series
-
-
-class ArrowExprNamespace(_ExprNamespace["ArrowExpr"]):
-    def __init__(self: Self, expr: ArrowExpr, /) -> None:
-        self._compliant_expr = expr

narwhals/_arrow/utils.py

@@ -15,6 +15,7 @@
 from narwhals._compliant.any_namespace import CatNamespace
 from narwhals._compliant.any_namespace import DateTimeNamespace
 from narwhals._compliant.any_namespace import ListNamespace
+from narwhals._compliant.any_namespace import NameNamespace
 from narwhals._compliant.any_namespace import StringNamespace
 from narwhals._compliant.namespace import CompliantNamespace
 from narwhals._compliant.typing import CompliantFrameT
@@ -46,7 +47,6 @@
 
     from typing_extensions import Self
 
-    from narwhals._compliant.any_namespace import NameNamespace
     from narwhals._compliant.namespace import CompliantNamespace
     from narwhals._compliant.namespace import EagerNamespace
     from narwhals._compliant.series import CompliantSeries
@@ -783,7 +783,8 @@ def str(self) -> EagerExprStringNamespace[Self]:
         return EagerExprStringNamespace(self)
 
     @property
-    def name(self) -> NameNamespace[Self]: ...
+    def name(self) -> EagerExprNameNamespace[Self]:
+        return EagerExprNameNamespace(self)
 
 
 # NOTE: See (https://github.com/narwhals-dev/narwhals/issues/2044#issuecomment-2674262833)
@@ -903,6 +904,77 @@ def len(self) -> EagerExprT:
         return self.compliant._reuse_series_namespace("list", "len")
 
 
+class EagerExprNameNamespace(
+    EagerExprNamespace[EagerExprT], NameNamespace[EagerExprT], Generic[EagerExprT]
+):
+    def keep(self) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=lambda name: name
+        )
+
+    def map(self, function: Callable[[str], str]) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=function,
+            alias_output_names=lambda output_names: [
+                function(name) for name in output_names
+            ],
+        )
+
+    def prefix(self, prefix: str) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=lambda name: f"{prefix}{name}",
+            alias_output_names=lambda output_names: [
+                f"{prefix}{output_name}" for output_name in output_names
+            ],
+        )
+
+    def suffix(self, suffix: str) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=lambda name: f"{name}{suffix}",
+            alias_output_names=lambda output_names: [
+                f"{output_name}{suffix}" for output_name in output_names
+            ],
+        )
+
+    def to_lowercase(self) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=str.lower,
+            alias_output_names=lambda output_names: [
+                name.lower() for name in output_names
+            ],
+        )
+
+    def to_uppercase(self) -> EagerExprT:
+        return self._from_colname_func_and_alias_output_names(
+            name_mapping_func=str.upper,
+            alias_output_names=lambda output_names: [
+                name.upper() for name in output_names
+            ],
+        )
+
+    def _from_colname_func_and_alias_output_names(
+        self,
+        name_mapping_func: Callable[[str], str],
+        alias_output_names: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> EagerExprT:
+        return type(self.compliant)(
+            call=lambda df: [
+                series.alias(name_mapping_func(name))
+                for series, name in zip(
+                    self.compliant._call(df), self.compliant._evaluate_output_names(df)
+                )
+            ],
+            depth=self.compliant._depth,
+            function_name=self.compliant._function_name,
+            evaluate_output_names=self.compliant._evaluate_output_names,
+            alias_output_names=alias_output_names,
+            backend_version=self.compliant._backend_version,
+            implementation=self.compliant._implementation,
+            version=self.compliant._version,
+            call_kwargs=self.compliant._call_kwargs,
+        )
+
+
 class EagerExprStringNamespace(
     EagerExprNamespace[EagerExprT], StringNamespace[EagerExprT], Generic[EagerExprT]
 ):

narwhals/_compliant/expr.py

@@ -11,7 +11,6 @@
 from narwhals._expression_parsing import ExprKind
 from narwhals._expression_parsing import evaluate_output_names_and_aliases
 from narwhals._expression_parsing import is_elementary_expression
-from narwhals._pandas_like.expr_name import PandasLikeExprNameNamespace
 from narwhals._pandas_like.group_by import AGGREGATIONS_TO_PANDAS_EQUIVALENT
 from narwhals._pandas_like.series import PandasLikeSeries
 from narwhals.dependencies import get_numpy
@@ -341,7 +340,3 @@ def rank(
         return self._reuse_series(
             "rank", call_kwargs={"method": method, "descending": descending}
         )
-
-    @property
-    def name(self: Self) -> PandasLikeExprNameNamespace:
-        return PandasLikeExprNameNamespace(self)