refactor: adds _Stores(Native|Compliant)

narwhals/_arrow/expr_cat.py

@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING
 
+from narwhals._arrow.utils import ArrowExprNamespace
 from narwhals._expression_parsing import reuse_series_namespace_implementation
 
 if TYPE_CHECKING:
@@ -10,11 +11,8 @@
     from narwhals._arrow.expr import ArrowExpr
 
 
-class ArrowExprCatNamespace:
-    def __init__(self: Self, expr: ArrowExpr) -> None:
-        self._compliant_expr = expr
-
+class ArrowExprCatNamespace(ArrowExprNamespace):
     def get_categories(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "cat", "get_categories"
+            self.compliant, "cat", "get_categories"
         )

narwhals/_arrow/expr_dt.py

@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING
 
+from narwhals._arrow.utils import ArrowExprNamespace
 from narwhals._expression_parsing import reuse_series_namespace_implementation
 
 if TYPE_CHECKING:
@@ -11,97 +12,84 @@
     from narwhals.typing import TimeUnit
 
 
-class ArrowExprDateTimeNamespace:
-    def __init__(self: Self, expr: ArrowExpr) -> None:
-        self._compliant_expr = expr
-
+class ArrowExprDateTimeNamespace(ArrowExprNamespace):
     def to_string(self: Self, format: str) -> ArrowExpr:  # noqa: A002
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "to_string", format=format
+            self.compliant, "dt", "to_string", format=format
         )
 
     def replace_time_zone(self: Self, time_zone: str | None) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "replace_time_zone", time_zone=time_zone
+            self.compliant, "dt", "replace_time_zone", time_zone=time_zone
         )
 
     def convert_time_zone(self: Self, time_zone: str) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "convert_time_zone", time_zone=time_zone
+            self.compliant, "dt", "convert_time_zone", time_zone=time_zone
         )
 
     def timestamp(self: Self, time_unit: TimeUnit) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "timestamp", time_unit=time_unit
+            self.compliant, "dt", "timestamp", time_unit=time_unit
         )
 
     def date(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "date")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "date")
 
     def year(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "year")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "year")
 
     def month(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "month")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "month")
 
     def day(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "day")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "day")
 
     def hour(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "hour")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "hour")
 
     def minute(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "minute")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "minute")
 
     def second(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._compliant_expr, "dt", "second")
+        return reuse_series_namespace_implementation(self.compliant, "dt", "second")
 
     def millisecond(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "millisecond"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "dt", "millisecond")
 
     def microsecond(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "microsecond"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "dt", "microsecond")
 
     def nanosecond(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "nanosecond"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "dt", "nanosecond")
 
     def ordinal_day(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "ordinal_day"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "dt", "ordinal_day")
 
     def weekday(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "weekday"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "dt", "weekday")
 
     def total_minutes(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "total_minutes"
+            self.compliant, "dt", "total_minutes"
         )
 
     def total_seconds(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "total_seconds"
+            self.compliant, "dt", "total_seconds"
         )
 
     def total_milliseconds(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "total_milliseconds"
+            self.compliant, "dt", "total_milliseconds"
         )
 
     def total_microseconds(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "total_microseconds"
+            self.compliant, "dt", "total_microseconds"
         )
 
     def total_nanoseconds(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "dt", "total_nanoseconds"
+            self.compliant, "dt", "total_nanoseconds"
         )

narwhals/_arrow/expr_list.py

@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING
 
+from narwhals._arrow.utils import ArrowExprNamespace
 from narwhals._expression_parsing import reuse_series_namespace_implementation
 
 if TYPE_CHECKING:
@@ -10,9 +11,6 @@
     from narwhals._arrow.expr import ArrowExpr
 
 
-class ArrowExprListNamespace:
-    def __init__(self: Self, expr: ArrowExpr) -> None:
-        self._expr = expr
-
+class ArrowExprListNamespace(ArrowExprNamespace):
     def len(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(self._expr, "list", "len")
+        return reuse_series_namespace_implementation(self.compliant, "list", "len")

narwhals/_arrow/expr_name.py

@@ -4,16 +4,15 @@
 from typing import Callable
 from typing import Sequence
 
+from narwhals._arrow.utils import ArrowExprNamespace
+
 if TYPE_CHECKING:
     from typing_extensions import Self
 
     from narwhals._arrow.expr import ArrowExpr
 
 
-class ArrowExprNameNamespace:
-    def __init__(self: Self, expr: ArrowExpr) -> None:
-        self._compliant_expr = expr
-
+class ArrowExprNameNamespace(ArrowExprNamespace):
     def keep(self: Self) -> ArrowExpr:
         return self._from_colname_func_and_alias_output_names(
             name_mapping_func=lambda name: name,
@@ -65,19 +64,18 @@ def _from_colname_func_and_alias_output_names(
         name_mapping_func: Callable[[str], str],
         alias_output_names: Callable[[Sequence[str]], Sequence[str]] | None,
     ) -> ArrowExpr:
-        return self._compliant_expr.__class__(
+        return self.compliant.__class__(
             call=lambda df: [
                 series.alias(name_mapping_func(name))
                 for series, name in zip(
-                    self._compliant_expr._call(df),
-                    self._compliant_expr._evaluate_output_names(df),
+                    self.compliant._call(df), self.compliant._evaluate_output_names(df)
                 )
             ],
-            depth=self._compliant_expr._depth,
-            function_name=self._compliant_expr._function_name,
-            evaluate_output_names=self._compliant_expr._evaluate_output_names,
+            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_expr._backend_version,
-            version=self._compliant_expr._version,
-            call_kwargs=self._compliant_expr._call_kwargs,
+            backend_version=self.compliant._backend_version,
+            version=self.compliant._version,
+            call_kwargs=self.compliant._call_kwargs,
         )

narwhals/_arrow/expr_str.py

@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING
 
+from narwhals._arrow.utils import ArrowExprNamespace
 from narwhals._expression_parsing import reuse_series_namespace_implementation
 
 if TYPE_CHECKING:
@@ -10,20 +11,15 @@
     from narwhals._arrow.expr import ArrowExpr
 
 
-class ArrowExprStringNamespace:
-    def __init__(self: Self, expr: ArrowExpr) -> None:
-        self._compliant_expr = expr
-
+class ArrowExprStringNamespace(ArrowExprNamespace):
     def len_chars(self: Self) -> ArrowExpr:
-        return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "len_chars"
-        )
+        return reuse_series_namespace_implementation(self.compliant, "str", "len_chars")
 
     def replace(
         self: Self, pattern: str, value: str, *, literal: bool, n: int
     ) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr,
+            self.compliant,
             "str",
             "replace",
             pattern=pattern,
@@ -34,7 +30,7 @@ def replace(
 
     def replace_all(self: Self, pattern: str, value: str, *, literal: bool) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr,
+            self.compliant,
             "str",
             "replace_all",
             pattern=pattern,
@@ -44,27 +40,27 @@ def replace_all(self: Self, pattern: str, value: str, *, literal: bool) -> Arrow
 
     def strip_chars(self: Self, characters: str | None) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "strip_chars", characters=characters
+            self.compliant, "str", "strip_chars", characters=characters
         )
 
     def starts_with(self: Self, prefix: str) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "starts_with", prefix=prefix
+            self.compliant, "str", "starts_with", prefix=prefix
         )
 
     def ends_with(self: Self, suffix: str) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "ends_with", suffix=suffix
+            self.compliant, "str", "ends_with", suffix=suffix
         )
 
     def contains(self: Self, pattern: str, *, literal: bool) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "contains", pattern=pattern, literal=literal
+            self.compliant, "str", "contains", pattern=pattern, literal=literal
         )
 
     def slice(self: Self, offset: int, length: int | None) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "slice", offset=offset, length=length
+            self.compliant, "str", "slice", offset=offset, length=length
         )
 
     def split(self: Self, by: str) -> ArrowExpr:
@@ -74,15 +70,15 @@ def split(self: Self, by: str) -> ArrowExpr:
 
     def to_datetime(self: Self, format: str | None) -> ArrowExpr:  # noqa: A002
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "to_datetime", format=format
+            self.compliant, "str", "to_datetime", format=format
         )
 
     def to_uppercase(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "to_uppercase"
+            self.compliant, "str", "to_uppercase"
         )
 
     def to_lowercase(self: Self) -> ArrowExpr:
         return reuse_series_namespace_implementation(
-            self._compliant_expr, "str", "to_lowercase"
+            self.compliant, "str", "to_lowercase"
         )