feat(DRAFT): Mock up to_compliant as an adapter

An experiment towards (#2572 (comment))

Author: dangotbanned

narwhals/_namespace.py

@@ -203,7 +203,9 @@ def from_backend(cls, backend: EagerAllowed, /) -> EagerAllowedNamespace: ...
 
     @overload
     @classmethod
-    def from_backend(cls, backend: ModuleType, /) -> Namespace[CompliantNamespaceAny]: ...
+    def from_backend(
+        cls, backend: IntoBackend, /
+    ) -> Namespace[CompliantNamespaceAny]: ...
 
     @classmethod
     def from_backend(

narwhals/_plan/common.py

@@ -4,20 +4,15 @@
 from decimal import Decimal
 from typing import TYPE_CHECKING, Generic, TypeVar
 
-from narwhals._plan.typing import IRNamespaceT
+from narwhals._plan.typing import ExprT, IRNamespaceT, Ns
 from narwhals.utils import Version
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Iterator
 
     from typing_extensions import Never, Self, TypeAlias, TypeIs, dataclass_transform
 
-    from narwhals._plan.dummy import (
-        DummyCompliantExpr,
-        DummyExpr,
-        DummySelector,
-        DummySeries,
-    )
+    from narwhals._plan.dummy import DummyExpr, DummySelector, DummySeries
     from narwhals._plan.expr import FunctionExpr
     from narwhals._plan.lists import IRListNamespace
     from narwhals._plan.meta import IRMetaNamespace
@@ -146,10 +141,8 @@ def to_narwhals(self, version: Version = Version.MAIN) -> DummyExpr:
             return dummy.DummyExpr._from_ir(self)
         return dummy.DummyExprV1._from_ir(self)
 
-    def to_compliant(self, version: Version = Version.MAIN) -> DummyCompliantExpr:
-        from narwhals._plan.dummy import DummyCompliantExpr
-
-        return DummyCompliantExpr._from_ir(self, version)
+    def to_compliant(self, plx: Ns[ExprT], /) -> ExprT:
+        raise NotImplementedError
 
     @property
     def is_scalar(self) -> bool:

narwhals/_plan/dummy.py

@@ -37,6 +37,7 @@
     from narwhals._plan.strings import ExprStringNamespace
     from narwhals._plan.struct import ExprStructNamespace
     from narwhals._plan.temporal import ExprDateTimeNamespace
+    from narwhals._plan.typing import ExprT, Ns
     from narwhals.typing import (
         FillNullStrategy,
         NativeSeries,
@@ -62,6 +63,9 @@ def _from_ir(cls, ir: ExprIR, /) -> Self:
         obj._ir = ir
         return obj
 
+    def _to_compliant(self, plx: Ns[ExprT], /) -> ExprT:
+        return self._ir.to_compliant(plx)
+
     @property
     def version(self) -> Version:
         return self._version

narwhals/_plan/expr.py

@@ -16,9 +16,11 @@
 from narwhals._plan.common import ExprIR, SelectorIR, _field_str
 from narwhals._plan.name import KeepName, RenameAlias
 from narwhals._plan.typing import (
+    ExprT,
     FunctionT,
     LeftSelectorT,
     LeftT,
+    Ns,
     OperatorT,
     RightSelectorT,
     RightT,
@@ -97,6 +99,9 @@ class Column(ExprIR):
     def __repr__(self) -> str:
         return f"col({self.name!r})"
 
+    def to_compliant(self, plx: Ns[ExprT], /) -> ExprT:
+        return plx.col(self.name)
+
 
 class Columns(ExprIR):
     __slots__ = ("names",)
@@ -106,6 +111,9 @@ class Columns(ExprIR):
     def __repr__(self) -> str:
         return f"cols({list(self.names)!r})"
 
+    def to_compliant(self, plx: Ns[ExprT], /) -> ExprT:
+        return plx.col(*self.names)
+
 
 class Literal(ExprIR):
     """https://github.com/pola-rs/polars/blob/dafd0a2d0e32b52bcfa4273bffdd6071a0d5977a/crates/polars-plan/src/dsl/expr.rs#L81."""
@@ -129,6 +137,9 @@ def name(self) -> str:
     def __repr__(self) -> str:
         return f"lit({self.value!r})"
 
+    def to_compliant(self, plx: Ns[ExprT], /) -> ExprT:
+        return plx.lit(self.value.unwrap(), self.dtype)
+
 
 class _BinaryOp(ExprIR, t.Generic[LeftT, OperatorT, RightT]):
     __slots__ = ("left", "op", "right")

narwhals/_plan/literal.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic
 
 from narwhals._plan.common import Immutable
 
@@ -10,8 +10,15 @@
     from narwhals.dtypes import DType
     from narwhals.typing import NonNestedLiteral
 
+from narwhals._typing_compat import TypeVar
 
-class LiteralValue(Immutable):
+T = TypeVar("T", default=Any)
+NonNestedLiteralT = TypeVar(
+    "NonNestedLiteralT", bound="NonNestedLiteral", default="NonNestedLiteral"
+)
+
+
+class LiteralValue(Immutable, Generic[T]):
     """https://github.com/pola-rs/polars/blob/dafd0a2d0e32b52bcfa4273bffdd6071a0d5977a/crates/polars-plan/src/plans/lit.rs#L67-L73."""
 
     @property
@@ -31,11 +38,14 @@ def to_literal(self) -> Literal:
 
         return Literal(value=self)
 
+    def unwrap(self) -> T:
+        raise NotImplementedError
+
 
-class ScalarLiteral(LiteralValue):
+class ScalarLiteral(LiteralValue[NonNestedLiteralT]):
     __slots__ = ("dtype", "value")
 
-    value: NonNestedLiteral
+    value: NonNestedLiteralT
     dtype: DType
 
     @property
@@ -47,8 +57,11 @@ def __repr__(self) -> str:
             return f"{type(self.value).__name__}: {self.value!s}"
         return "null"
 
+    def unwrap(self) -> NonNestedLiteralT:
+        return self.value
+
 
-class SeriesLiteral(LiteralValue):
+class SeriesLiteral(LiteralValue["DummySeries"]):
     """We already need this.
 
     https://github.com/narwhals-dev/narwhals/blob/e51eba891719a5eb1f7ce91c02a477af39c0baee/narwhals/_expression_parsing.py#L96-L97
@@ -69,6 +82,9 @@ def name(self) -> str:
     def __repr__(self) -> str:
         return "Series"
 
+    def unwrap(self) -> DummySeries:
+        return self.value
+
 
 class RangeLiteral(LiteralValue):
     """Don't need yet, but might push forward the discussions.

narwhals/_plan/typing.py

@@ -5,6 +5,10 @@
 from narwhals._typing_compat import TypeVar
 
 if t.TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    from narwhals._compliant import CompliantNamespace as Namespace
+    from narwhals._compliant.typing import CompliantExprAny
     from narwhals._plan import operators as ops
     from narwhals._plan.common import ExprIR, Function, IRNamespace, SelectorIR
     from narwhals._plan.functions import RollingWindow
@@ -24,3 +28,10 @@
     "SelectorOperatorT", bound="ops.SelectorOperator", default="ops.SelectorOperator"
 )
 IRNamespaceT = TypeVar("IRNamespaceT", bound="IRNamespace")
+# NOTE: Shorter aliases of `_compliant.typing`
+# - Aiming to try and preserve the types as much as possible
+# - Recursion between `Expr` and `Frame` is an issue
+Expr: TypeAlias = "CompliantExprAny"
+ExprT = TypeVar("ExprT", bound="Expr")
+Ns: TypeAlias = "Namespace[t.Any, ExprT]"
+"""A `CompliantNamespace`, ignoring the `Frame` type."""

tests/plan/to_compliant_test.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+import narwhals as nw
+import narwhals._plan.demo as nwd
+from narwhals.utils import Version
+from tests.namespace_test import backends
+
+if TYPE_CHECKING:
+    from narwhals._namespace import BackendName
+    from narwhals._plan.dummy import DummyExpr
+
+
+def _ids_ir(expr: DummyExpr) -> str:
+    return repr(expr._ir)
+
+
+@pytest.mark.parametrize(
+    ("expr"),
+    [
+        nwd.col("a"),
+        nwd.col("a", "b"),
+        nwd.lit(1),
+        nwd.lit(2.0),
+        nwd.lit(None, nw.String()),
+    ],
+    ids=_ids_ir,
+)
+@backends
+def test_to_compliant(backend: BackendName, expr: DummyExpr) -> None:
+    pytest.importorskip(backend)
+    namespace = Version.MAIN.namespace.from_backend(backend).compliant
+    compliant_expr = expr._to_compliant(namespace)
+    assert isinstance(compliant_expr, namespace._expr)