feat: Define CompliantSeries._to_expr

Resolves: (#2149 (comment))

Doing this properly surfaced lots of issues
- `Polars*` classes are *similar* to `Compliant*`
  - Not close enough to support typing
  - Lots of stuff is behind `__getattr__`
  - We don't need `PolarsExpr` to do a lot of the work `CompliantExpr` does
- `nw.Series._compliant_series` is still a big PR away
  - Repeat of (#2119)
  - Last big hurdle to get (#2104 (comment))

Author: dangotbanned

narwhals/_compliant/series.py

@@ -9,6 +9,10 @@
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from narwhals._compliant.expr import CompliantExpr  # noqa: F401
+    from narwhals._compliant.expr import EagerExpr
+    from narwhals._compliant.namespace import CompliantNamespace  # noqa: F401
+    from narwhals._compliant.namespace import EagerNamespace
     from narwhals.dtypes import DType
     from narwhals.typing import NativeSeries
     from narwhals.utils import Implementation
@@ -27,6 +31,8 @@ def dtype(self) -> DType: ...
     def name(self) -> str: ...
     def __narwhals_series__(self) -> CompliantSeries: ...
     def alias(self, name: str) -> Self: ...
+    def __narwhals_namespace__(self) -> Any: ...  # CompliantNamespace[Any, Self]: ...
+    def _to_expr(self) -> Any: ...  # CompliantExpr[Any, Self]: ...
 
 
 class EagerSeries(CompliantSeries, Protocol[NativeSeriesT_co]):
@@ -50,6 +56,11 @@ def _from_iterable(
         cls: type[Self], data: Iterable[Any], name: str, *, context: _FullContext
     ) -> Self: ...
 
+    def __narwhals_namespace__(self) -> EagerNamespace[Any, Self]: ...
+
+    def _to_expr(self) -> EagerExpr[Any, Self]:
+        return self.__narwhals_namespace__()._expr._from_series(self)
+
     # TODO @dangotbanned: replacing `Namespace._create_compliant_series``
     # - All usage within `*Expr.map_batches`
     #   - `PandasLikeExpr` uses that **once**

narwhals/_expression_parsing.py

@@ -18,7 +18,6 @@
 from narwhals.exceptions import LengthChangingExprError
 from narwhals.exceptions import ShapeError
 from narwhals.utils import is_compliant_expr
-from narwhals.utils import is_eager_namespace
 
 if TYPE_CHECKING:
     from typing_extensions import Never
@@ -132,14 +131,9 @@ def extract_compliant(
     if isinstance(other, str) and not str_as_lit:
         return plx.col(other)
     if is_narwhals_series(other):
-        if is_eager_namespace(plx):
-            return plx._expr._from_series(other._compliant_series)
-        return plx._create_expr_from_series(other._compliant_series)  # type: ignore[attr-defined]
+        return other._compliant_series._to_expr()
     if is_numpy_array(other):
-        if is_eager_namespace(plx):
-            return plx._expr._from_series(plx._create_compliant_series(other))
-        series = plx._create_compliant_series(other)  # type: ignore[attr-defined]
-        return plx._create_expr_from_series(series)  # type: ignore[attr-defined]
+        return plx._create_compliant_series(other)._to_expr()  # type: ignore[attr-defined]
     return other
 
 

narwhals/_pandas_like/series.py

@@ -39,6 +39,7 @@
 
     from narwhals._arrow.typing import ArrowArray
     from narwhals._pandas_like.dataframe import PandasLikeDataFrame
+    from narwhals._pandas_like.namespace import PandasLikeNamespace
     from narwhals.dtypes import DType
     from narwhals.typing import _1DArray
     from narwhals.typing import _AnyDArray
@@ -131,6 +132,13 @@ def __native_namespace__(self: Self) -> ModuleType:
     def __narwhals_series__(self: Self) -> Self:
         return self
 
+    def __narwhals_namespace__(self) -> PandasLikeNamespace:
+        from narwhals._pandas_like.namespace import PandasLikeNamespace
+
+        return PandasLikeNamespace(
+            self._implementation, self._backend_version, self._version
+        )
+
     @overload
     def __getitem__(self: Self, idx: int) -> Any: ...
 

narwhals/_polars/expr.py

@@ -38,6 +38,14 @@ def _from_native_expr(self: Self, expr: pl.Expr) -> Self:
             expr, version=self._version, backend_version=self._backend_version
         )
 
+    @classmethod
+    def _from_series(cls, series: Any) -> Self:
+        return cls(
+            series._native_series,
+            version=series._version,
+            backend_version=series._backend_version,
+        )
+
     def broadcast(self, kind: Literal[ExprKind.AGGREGATION, ExprKind.LITERAL]) -> Self:
         # Let Polars do its thing.
         return self

narwhals/_polars/namespace.py

@@ -49,19 +49,19 @@ def func(*args: Any, **kwargs: Any) -> Any:
 
         return func
 
+    @property
+    def _expr(self) -> type[PolarsExpr]:
+        return PolarsExpr
+
+    @property
+    def _series(self) -> type[PolarsSeries]:
+        return PolarsSeries
+
     def _create_compliant_series(self, value: Any) -> PolarsSeries:
         return PolarsSeries(
             pl.Series(value), backend_version=self._backend_version, version=self._version
         )
 
-    def _create_expr_from_series(self, value: Any) -> PolarsExpr:
-        # Let Polars do its own thing.
-        return PolarsExpr(
-            value._native_series,
-            version=self._version,
-            backend_version=self._backend_version,
-        )
-
     def nth(self: Self, *indices: int) -> PolarsExpr:
         from narwhals._polars.expr import PolarsExpr
 

narwhals/_polars/series.py

@@ -23,6 +23,8 @@
     from typing_extensions import Self
 
     from narwhals._polars.dataframe import PolarsDataFrame
+    from narwhals._polars.expr import PolarsExpr
+    from narwhals._polars.namespace import PolarsNamespace
     from narwhals.dtypes import DType
     from narwhals.typing import _1DArray
     from narwhals.utils import Version
@@ -47,6 +49,13 @@ def __init__(
     def __repr__(self: Self) -> str:  # pragma: no cover
         return "PolarsSeries"
 
+    def __narwhals_namespace__(self) -> PolarsNamespace:
+        from narwhals._polars.namespace import PolarsNamespace
+
+        return PolarsNamespace(
+            backend_version=self._backend_version, version=self._version
+        )
+
     def __narwhals_series__(self: Self) -> Self:
         return self
 
@@ -90,6 +99,9 @@ def _from_native_object(
         # scalar
         return series
 
+    def _to_expr(self) -> PolarsExpr:
+        return self.__narwhals_namespace__()._expr._from_series(self)
+
     def __getattr__(self: Self, attr: str) -> Any:
         if attr == "as_py":  # pragma: no cover
             raise AttributeError

narwhals/dataframe.py

@@ -33,7 +33,6 @@
 from narwhals.utils import find_stacklevel
 from narwhals.utils import flatten
 from narwhals.utils import generate_repr
-from narwhals.utils import is_eager_namespace
 from narwhals.utils import is_sequence_but_not_str
 from narwhals.utils import issue_deprecation_warning
 from narwhals.utils import parse_version
@@ -430,9 +429,7 @@ def _extract_compliant(self: Self, arg: Any) -> Any:
         if isinstance(arg, BaseFrame):
             return arg._compliant_frame
         if isinstance(arg, Series):
-            if is_eager_namespace(plx):
-                return plx._expr._from_series(arg._compliant_series)
-            return plx._create_expr_from_series(arg._compliant_series)
+            return arg._compliant_series._to_expr()
         if isinstance(arg, Expr):
             return arg._to_compliant_expr(self.__narwhals_namespace__())
         if isinstance(arg, str):
@@ -446,9 +443,7 @@ def _extract_compliant(self: Self, arg: Any) -> Any:
             )
             raise TypeError(msg)
         if is_numpy_array(arg):
-            if is_eager_namespace(plx):
-                return plx._expr._from_series(plx._create_compliant_series(arg))
-            return plx._create_expr_from_series(plx._create_compliant_series(arg))
+            return plx._create_compliant_series(arg)._to_expr()
         raise InvalidIntoExprError.from_invalid_type(type(arg))
 
     @property

narwhals/series.py

@@ -76,6 +76,8 @@ def __init__(
     ) -> None:
         self._level: Literal["full", "lazy", "interchange"] = level
         if hasattr(series, "__narwhals_series__"):
+            # TODO @dangotbanned: Repeat (#2119) for `CompliantSeries` to support typing
+            # morally: `CompliantSeries`
             self._compliant_series = series.__narwhals_series__()
         else:  # pragma: no cover
             msg = f"Expected Polars Series or an object which implements `__narwhals_series__`, got: {type(series)}."

narwhals/utils.py

@@ -56,9 +56,6 @@
     from narwhals._compliant import CompliantFrameT
     from narwhals._compliant import CompliantSeriesOrNativeExprT_co
     from narwhals._compliant import CompliantSeriesT_co
-    from narwhals._compliant import EagerDataFrameT
-    from narwhals._compliant import EagerNamespace
-    from narwhals._compliant import EagerSeriesT
     from narwhals.dataframe import DataFrame
     from narwhals.dataframe import LazyFrame
     from narwhals.dtypes import DType
@@ -1402,14 +1399,6 @@ def is_compliant_expr(
     return hasattr(obj, "__narwhals_expr__")
 
 
-# NOTE: Temporary - just to introduce a path for the (Arrow|PandasLike) WIP
-def is_eager_namespace(
-    obj: EagerNamespace[EagerDataFrameT, EagerSeriesT] | Any,
-) -> TypeIs[EagerNamespace[EagerDataFrameT, EagerSeriesT]]:
-    return type(obj).__name__ in {"ArrowNamespace", "PandasLikeNamespace"}
-    # return all(hasattr(obj, name) for name in ("selectors", "_expr", "_series"))  # noqa: ERA001
-
-
 def has_native_namespace(obj: Any) -> TypeIs[SupportsNativeNamespace]:
     return hasattr(obj, "__native_namespace__")