rollback dict annotation?

Author: FBruzzesi

pyproject.toml

@@ -94,6 +94,7 @@ convention = "google"
 
 [tool.ruff.lint.isort]
 force-single-line = true
+required-imports = ["from __future__ import annotations"]
 
 [tool.ruff.format]
 docstring-code-format = true

tests/conftest.py

@@ -48,47 +48,47 @@ def pytest_collection_modifyitems(config: Any, items: Any) -> Any:  # pragma: no
             item.add_marker(skip_slow)
 
 
-def pandas_constructor(obj: dict[str, Any]) -> IntoDataFrame:
+def pandas_constructor(obj: Any) -> IntoDataFrame:
     return pd.DataFrame(obj)  # type: ignore[no-any-return]
 
 
-def pandas_nullable_constructor(obj: dict[str, Any]) -> IntoDataFrame:
+def pandas_nullable_constructor(obj: Any) -> IntoDataFrame:
     return pd.DataFrame(obj).convert_dtypes(dtype_backend="numpy_nullable")  # type: ignore[no-any-return]
 
 
-def pandas_pyarrow_constructor(obj: dict[str, Any]) -> IntoDataFrame:
+def pandas_pyarrow_constructor(obj: Any) -> IntoDataFrame:
     return pd.DataFrame(obj).convert_dtypes(dtype_backend="pyarrow")  # type: ignore[no-any-return]
 
 
-def modin_constructor(obj: dict[str, Any]) -> IntoDataFrame:  # pragma: no cover
+def modin_constructor(obj: Any) -> IntoDataFrame:  # pragma: no cover
     mpd = get_modin()
     return mpd.DataFrame(pd.DataFrame(obj)).convert_dtypes(dtype_backend="pyarrow")  # type: ignore[no-any-return]
 
 
-def cudf_constructor(obj: dict[str, Any]) -> IntoDataFrame:  # pragma: no cover
+def cudf_constructor(obj: Any) -> IntoDataFrame:  # pragma: no cover
     cudf = get_cudf()
     return cudf.DataFrame(obj)  # type: ignore[no-any-return]
 
 
-def polars_eager_constructor(obj: dict[str, Any]) -> IntoDataFrame:
+def polars_eager_constructor(obj: Any) -> IntoDataFrame:
     return pl.DataFrame(obj)
 
 
-def polars_lazy_constructor(obj: dict[str, Any]) -> pl.LazyFrame:
+def polars_lazy_constructor(obj: Any) -> pl.LazyFrame:
     return pl.LazyFrame(obj)
 
 
-def dask_lazy_p1_constructor(obj: dict[str, Any]) -> IntoFrame:  # pragma: no cover
+def dask_lazy_p1_constructor(obj: Any) -> IntoFrame:  # pragma: no cover
     dd = get_dask_dataframe()
     return dd.from_dict(obj, npartitions=1)  # type: ignore[no-any-return]
 
 
-def dask_lazy_p2_constructor(obj: dict[str, Any]) -> IntoFrame:  # pragma: no cover
+def dask_lazy_p2_constructor(obj: Any) -> IntoFrame:  # pragma: no cover
     dd = get_dask_dataframe()
     return dd.from_dict(obj, npartitions=2)  # type: ignore[no-any-return]
 
 
-def pyarrow_table_constructor(obj: dict[str, Any]) -> IntoDataFrame:
+def pyarrow_table_constructor(obj: Any) -> IntoDataFrame:
     return pa.table(obj)  # type: ignore[no-any-return]
 
 
@@ -115,7 +115,7 @@ def pyarrow_table_constructor(obj: dict[str, Any]) -> IntoDataFrame:
 @pytest.fixture(params=eager_constructors)
 def constructor_eager(
     request: pytest.FixtureRequest,
-) -> Callable[[dict[str, Any]], IntoDataFrame]:
+) -> Callable[[Any], IntoDataFrame]:
     return request.param  # type: ignore[no-any-return]
 
 

tests/frame/rows_test.py

@@ -4,44 +4,15 @@
 from typing import Any
 
 import pandas as pd
-import polars as pl
-import pyarrow as pa
 import pytest
 
 import narwhals.stable.v1 as nw
-from narwhals.utils import parse_version
 
 if TYPE_CHECKING:
     from tests.utils import ConstructorEager
 
-df_pandas = pd.DataFrame({"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]})
-df_pa = pa.table({"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]})
-if parse_version(pd.__version__) >= parse_version("1.5.0"):
-    df_pandas_pyarrow = pd.DataFrame(
-        {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]}
-    ).astype(
-        {
-            "a": "Int64[pyarrow]",
-            "b": "Int64[pyarrow]",
-            "z": "Float64[pyarrow]",
-        }
-    )
-    df_pandas_nullable = pd.DataFrame(
-        {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]}
-    ).astype(
-        {
-            "a": "Int64",
-            "b": "Int64",
-            "z": "Float64",
-        }
-    )
-else:  # pragma: no cover
-    df_pandas_pyarrow = df_pandas
-    df_pandas_nullable = df_pandas
-df_polars = pl.DataFrame({"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]})
-
-df_pandas_na = pd.DataFrame({"a": [None, 3, 2], "b": [4, 4, 6], "z": [7.0, None, 9]})
-df_polars_na = pl.DataFrame({"a": [None, 3, 2], "b": [4, 4, 6], "z": [7.0, None, 9]})
+data = {"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.0, 8, 9]}
+data_na = {"a": [None, 3, 2], "b": [4, 4, 6], "z": [7.0, None, 9]}
 
 
 @pytest.mark.parametrize(
@@ -73,9 +44,6 @@ def test_iter_rows(
     assert result == expected
 
 
-@pytest.mark.parametrize(
-    "df_raw", [df_pandas, df_pandas_nullable, df_pandas_pyarrow, df_polars, df_pa]
-)
 @pytest.mark.parametrize(
     ("named", "expected"),
     [
@@ -91,19 +59,18 @@ def test_iter_rows(
     ],
 )
 def test_rows(
-    df_raw: Any,
+    constructor_eager: ConstructorEager,
     named: bool,  # noqa: FBT001
     expected: list[tuple[Any, ...]] | list[dict[str, Any]],
 ) -> None:
-    df = nw.from_native(df_raw, eager_only=True)
+    df = nw.from_native(constructor_eager(data), eager_only=True)
     result = df.rows(named=named)
     assert result == expected
 
 
-@pytest.mark.parametrize("df_raw", [df_pandas_na, df_polars_na])
-def test_rows_with_nulls_unnamed(df_raw: Any) -> None:
+def test_rows_with_nulls_unnamed(constructor_eager: ConstructorEager) -> None:
     # GIVEN
-    df = nw.from_native(df_raw, eager_only=True)
+    df = nw.from_native(constructor_eager(data_na), eager_only=True)
 
     # WHEN
     result = list(df.iter_rows(named=False))
@@ -119,10 +86,9 @@ def test_rows_with_nulls_unnamed(df_raw: Any) -> None:
                 assert value_in_result == value
 
 
-@pytest.mark.parametrize("df_raw", [df_pandas_na, df_polars_na])
-def test_rows_with_nulls_named(df_raw: Any) -> None:
+def test_rows_with_nulls_named(constructor_eager: ConstructorEager) -> None:
     # GIVEN
-    df = nw.from_native(df_raw, eager_only=True)
+    df = nw.from_native(constructor_eager(data_na), eager_only=True)
 
     # WHEN
     result = list(df.iter_rows(named=True))

tests/utils.py

@@ -19,8 +19,8 @@
 else:
     from typing_extensions import TypeAlias  # pragma: no cover
 
-Constructor: TypeAlias = Callable[[dict[str, Any]], IntoFrame]
-ConstructorEager: TypeAlias = Callable[[dict[str, Any]], IntoDataFrame]
+Constructor: TypeAlias = Callable[[Any], IntoFrame]
+ConstructorEager: TypeAlias = Callable[[Any], IntoDataFrame]
 
 
 def zip_strict(left: Sequence[Any], right: Sequence[Any]) -> Iterator[Any]: