fix(typing): Narrow TypeVar(s) used in (Data|Lazy)Frame

narwhals/dependencies.py

@@ -26,7 +26,6 @@
     from narwhals.dataframe import DataFrame
     from narwhals.dataframe import LazyFrame
     from narwhals.series import Series
-    from narwhals.typing import DataFrameT
     from narwhals.typing import FrameT
     from narwhals.typing import IntoDataFrameT
     from narwhals.typing import IntoSeriesT
@@ -364,8 +363,8 @@ def is_into_dataframe(native_dataframe: Any | IntoDataFrameT) -> TypeIs[IntoData
 
 
 def is_narwhals_dataframe(
-    df: Any | DataFrame[DataFrameT],
-) -> TypeIs[DataFrame[DataFrameT]]:
+    df: DataFrame[IntoDataFrameT] | Any,
+) -> TypeIs[DataFrame[IntoDataFrameT]]:
     """Check whether `df` is a Narwhals DataFrame.
 
     This is useful if you expect a user to pass in a Narwhals

narwhals/translate.py

@@ -44,12 +44,14 @@
     from narwhals.dataframe import DataFrame
     from narwhals.dataframe import LazyFrame
     from narwhals.series import Series
+    from narwhals.typing import DataFrameT
     from narwhals.typing import IntoDataFrameT
     from narwhals.typing import IntoFrame
     from narwhals.typing import IntoFrameT
     from narwhals.typing import IntoLazyFrameT
     from narwhals.typing import IntoSeries
     from narwhals.typing import IntoSeriesT
+    from narwhals.typing import LazyFrameT
     from narwhals.typing import SeriesT
 
 T = TypeVar("T")
@@ -134,14 +136,11 @@ def from_native(native_object: SeriesT, **kwds: Any) -> SeriesT: ...
 
 
 @overload
-def from_native(
-    native_object: IntoDataFrameT | IntoSeries,
-    *,
-    pass_through: Literal[True],
-    eager_only: Literal[False] = ...,
-    series_only: Literal[False] = ...,
-    allow_series: Literal[True],
-) -> DataFrame[IntoDataFrameT]: ...
+def from_native(native_object: DataFrameT, **kwds: Any) -> DataFrameT: ...
+
+
+@overload
+def from_native(native_object: LazyFrameT, **kwds: Any) -> LazyFrameT: ...
 
 
 @overload
@@ -235,7 +234,6 @@ def from_native(  # type: ignore[overload-overlap]
 ) -> LazyFrame[IntoLazyFrameT]: ...
 
 
-# NOTE: `pl.LazyFrame` originally matched here
 @overload
 def from_native(
     native_object: IntoDataFrameT,
@@ -280,17 +278,6 @@ def from_native(
 ) -> Series[IntoSeriesT]: ...
 
 
-@overload
-def from_native(
-    native_object: IntoFrameT | IntoLazyFrameT,
-    *,
-    pass_through: Literal[False] = ...,
-    eager_only: Literal[False] = ...,
-    series_only: Literal[False] = ...,
-    allow_series: None = ...,
-) -> DataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT]: ...
-
-
 # All params passed in as variables
 @overload
 def from_native(

narwhals/typing.py

@@ -57,7 +57,7 @@ def __native_namespace__(self) -> ModuleType: ...
 which will be interpreted as a `nw.Expr`, e.g. `df.select('a')`.
 """
 
-IntoDataFrame: TypeAlias = Union["NativeFrame", "DataFrame[Any]", "DataFrameLike"]
+IntoDataFrame: TypeAlias = Union["NativeFrame", "DataFrameLike"]
 """Anything which can be converted to a Narwhals DataFrame.
 
 Use this if your function accepts a narwhalifiable object but doesn't care about its backend.
@@ -70,11 +70,9 @@ def __native_namespace__(self) -> ModuleType: ...
     ...     return df.shape
 """
 
-IntoLazyFrame: TypeAlias = "NativeLazyFrame | LazyFrame[Any]"
+IntoLazyFrame: TypeAlias = "NativeLazyFrame"
 
-IntoFrame: TypeAlias = Union[
-    "NativeFrame", "DataFrame[Any]", "LazyFrame[Any]", "DataFrameLike"
-]
+IntoFrame: TypeAlias = "IntoDataFrame | IntoLazyFrame"
 """Anything which can be converted to a Narwhals DataFrame or LazyFrame.
 
 Use this if your function can accept an object which can be converted to either

tests/translate/from_native_test.py

@@ -369,6 +369,48 @@ def test_from_native_lazyframe() -> None:
     assert isinstance(unstable_lazy, unstable_nw.LazyFrame)
 
 
+def test_dataframe_recursive() -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    pl_frame = pl.DataFrame({"a": [1, 2, 3]})
+    nw_frame = unstable_nw.from_native(pl_frame)
+    with pytest.raises(AssertionError):
+        unstable_nw.DataFrame(nw_frame, level="full")
+
+    nw_frame_early_return = unstable_nw.from_native(nw_frame)
+
+    if TYPE_CHECKING:
+        assert_type(pl_frame, pl.DataFrame)
+        assert_type(nw_frame, unstable_nw.DataFrame[pl.DataFrame])
+
+        nw_frame_depth_2 = unstable_nw.DataFrame(nw_frame, level="full")  # type: ignore[var-annotated]
+        # NOTE: Checking that the type is `DataFrame[Unknown]`
+        assert_type(nw_frame_depth_2, unstable_nw.DataFrame)  # type: ignore[type-arg]
+        assert_type(nw_frame_early_return, unstable_nw.DataFrame[pl.DataFrame])
+
+
+def test_lazyframe_recursive() -> None:
+    pytest.importorskip("polars")
+    import polars as pl
+
+    pl_frame = pl.DataFrame({"a": [1, 2, 3]}).lazy()
+    nw_frame = unstable_nw.from_native(pl_frame)
+    with pytest.raises(AssertionError):
+        unstable_nw.LazyFrame(nw_frame, level="lazy")
+
+    nw_frame_early_return = unstable_nw.from_native(nw_frame)
+
+    if TYPE_CHECKING:
+        assert_type(pl_frame, pl.LazyFrame)
+        assert_type(nw_frame, unstable_nw.LazyFrame[pl.LazyFrame])
+
+        nw_frame_depth_2 = unstable_nw.LazyFrame(nw_frame, level="lazy")  # type: ignore[var-annotated]
+        # NOTE: Checking that the type is `LazyFrame[Unknown]`
+        assert_type(nw_frame_depth_2, unstable_nw.LazyFrame)  # type: ignore[type-arg]
+        assert_type(nw_frame_early_return, unstable_nw.LazyFrame[pl.LazyFrame])
+
+
 def test_series_recursive() -> None:
     """https://github.com/narwhals-dev/narwhals/issues/2239."""
     pytest.importorskip("polars")