Repository: narwhals-dev/narwhals
Pull request #1085 (2024-09-28 09:06:10)

docs: Added new logo
<!--
# Thanks for contributing a pull request! 
## Please make sure you see our contribution guidelines: https://github.com/narwhals-dev/narwhals/blob/main/CONTRIBUTING.md
-->

## What type of PR is this? (check all applicable)

- [ ] 💾 Refactor
- [ ] ✨ Feature
- [ ] 🐛 Bug Fix
- [ ] 🔧 Optimization
- [x] 📝 Documentation
- [ ] ✅ Test
- [ ] 🐳 Other

## Related issues 

- Related issue # 
- Closes #

## Checklist

- [ ] Code follows style guide (ruff)
- [ ] Tests added 
- [ ] Documented the changes

## If you have comments or can explain your changes, please do so below.




Patch:
diff --git a/docs/assets/logo.svg b/docs/assets/logo.svg
new file mode 100644
index 00000000..56ecf5c5
--- /dev/null
+++ b/docs/assets/logo.svg
@@ -0,0 +1,6 @@
+<svg 
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ width="342px" height="342px">
+<image  x="0px" y="0px" width="342px" height="342px"  xlink:href="data:img/png;base64,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" />
+</svg>
\ No newline at end of file
diff --git a/docs/css/mkdocstrings.css b/docs/css/mkdocstrings.css
new file mode 100644
index 00000000..0951698a
--- /dev/null
+++ b/docs/css/mkdocstrings.css
@@ -0,0 +1,9 @@
+.md-header__topic {
+    font-size: 200%;
+    font-family: Verdana, Geneva, Tahoma, sans-serif;
+}
+
+.md-header__button.md-logo img {
+    height: 22%;
+    width: 22%;
+  }
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 045a6a67..ccd4307a 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -47,8 +47,8 @@ nav:
 theme:
   name: material
   font: false
-  favicon: assets/image.png
-  logo: assets/image.png
+  favicon: assets/logo.svg
+  logo: assets/logo.svg
   features:
     - content.code.copy
     - content.code.annotate
@@ -75,6 +75,9 @@ theme:
       toggle:
         icon: material/brightness-4
         name: Switch to system preference
+extra_css:
+  - https://unpkg.com/katex@0/dist/katex.min.css
+  - css/mkdocstrings.css
 
 plugins:
 - search
diff --git a/narwhals/_arrow/dataframe.py b/narwhals/_arrow/dataframe.py
index 71723864..12cb16d2 100644
--- a/narwhals/_arrow/dataframe.py
+++ b/narwhals/_arrow/dataframe.py
@@ -10,8 +10,8 @@ from typing import overload
 
 from narwhals._arrow.utils import broadcast_series
 from narwhals._arrow.utils import convert_str_slice_to_int_slice
+from narwhals._arrow.utils import native_to_narwhals_dtype
 from narwhals._arrow.utils import select_rows
-from narwhals._arrow.utils import translate_dtype
 from narwhals._arrow.utils import validate_dataframe_comparand
 from narwhals._expression_parsing import evaluate_into_exprs
 from narwhals.dependencies import is_numpy_array
@@ -234,7 +234,7 @@ class ArrowDataFrame:
     def schema(self) -> dict[str, DType]:
         schema = self._native_frame.schema
         return {
-            name: translate_dtype(dtype)
+            name: native_to_narwhals_dtype(dtype)
             for name, dtype in zip(schema.names, schema.types)
         }
 
diff --git a/narwhals/_arrow/namespace.py b/narwhals/_arrow/namespace.py
index 6f699fa2..e1fb8c6b 100644
--- a/narwhals/_arrow/namespace.py
+++ b/narwhals/_arrow/namespace.py
@@ -16,6 +16,7 @@ from narwhals._arrow.utils import horizontal_concat
 from narwhals._arrow.utils import vertical_concat
 from narwhals._expression_parsing import combine_root_names
 from narwhals._expression_parsing import parse_into_exprs
+from narwhals._expression_parsing import reduce_output_names
 from narwhals.utils import Implementation
 
 if TYPE_CHECKING:
@@ -183,9 +184,7 @@ class ArrowNamespace:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: ArrowDataFrame) -> list[ArrowSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = (s for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x & y, series)]
 
         return self._create_expr_from_callable(
@@ -193,16 +192,14 @@ class ArrowNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="all_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def any_horizontal(self, *exprs: IntoArrowExpr) -> ArrowExpr:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: ArrowDataFrame) -> list[ArrowSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = (s for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x | y, series)]
 
         return self._create_expr_from_callable(
@@ -210,16 +207,14 @@ class ArrowNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="any_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def sum_horizontal(self, *exprs: IntoArrowExpr) -> ArrowExpr:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: ArrowDataFrame) -> list[ArrowSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend([_series.fill_null(0) for _series in _expr._call(df)])
+            series = (s.fill_null(0) for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x + y, series)]
 
         return self._create_expr_from_callable(
@@ -227,7 +222,7 @@ class ArrowNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="sum_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def mean_horizontal(self, *exprs: IntoArrowExpr) -> IntoArrowExpr:
diff --git a/narwhals/_arrow/series.py b/narwhals/_arrow/series.py
index f3888bc5..a3c3e89e 100644
--- a/narwhals/_arrow/series.py
+++ b/narwhals/_arrow/series.py
@@ -11,7 +11,7 @@ from typing import overload
 from narwhals._arrow.utils import cast_for_truediv
 from narwhals._arrow.utils import floordiv_compat
 from narwhals._arrow.utils import narwhals_to_native_dtype
-from narwhals._arrow.utils import translate_dtype
+from narwhals._arrow.utils import native_to_narwhals_dtype
 from narwhals._arrow.utils import validate_column_comparand
 from narwhals.utils import Implementation
 from narwhals.utils import generate_unique_token
@@ -365,7 +365,7 @@ class ArrowSeries:
 
     @property
     def dtype(self: Self) -> DType:
-        return translate_dtype(self._native_series.type)
+        return native_to_narwhals_dtype(self._native_series.type)
 
     def abs(self) -> Self:
         import pyarrow.compute as pc  # ignore-banned-import()
diff --git a/narwhals/_arrow/utils.py b/narwhals/_arrow/utils.py
index 7d6844e5..90195a38 100644
--- a/narwhals/_arrow/utils.py
+++ b/narwhals/_arrow/utils.py
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from narwhals._arrow.series import ArrowSeries
 
 
-def translate_dtype(dtype: Any) -> dtypes.DType:
+def native_to_narwhals_dtype(dtype: Any) -> dtypes.DType:
     import pyarrow as pa  # ignore-banned-import
 
     if pa.types.is_int64(dtype):
diff --git a/narwhals/_dask/dataframe.py b/narwhals/_dask/dataframe.py
index fd40e876..9538d6d8 100644
--- a/narwhals/_dask/dataframe.py
+++ b/narwhals/_dask/dataframe.py
@@ -8,7 +8,7 @@ from typing import Sequence
 
 from narwhals._dask.utils import add_row_index
 from narwhals._dask.utils import parse_exprs_and_named_exprs
-from narwhals._pandas_like.utils import translate_dtype
+from narwhals._pandas_like.utils import native_to_narwhals_dtype
 from narwhals.utils import Implementation
 from narwhals.utils import flatten
 from narwhals.utils import generate_unique_token
@@ -98,9 +98,6 @@ class DaskLazyFrame:
         mask = expr._call(self)[0]
         return self._from_native_frame(self._native_frame.loc[mask])
 
-    def lazy(self) -> Self:
-        return self
-
     def select(
         self: Self,
         *exprs: IntoDaskExpr,
@@ -143,7 +140,7 @@ class DaskLazyFrame:
     @property
     def schema(self) -> dict[str, DType]:
         return {
-            col: translate_dtype(self._native_frame.loc[:, col])
+            col: native_to_narwhals_dtype(self._native_frame.loc[:, col])
             for col in self._native_frame.columns
         }
 
diff --git a/narwhals/_dask/namespace.py b/narwhals/_dask/namespace.py
index 7d661f06..39c64719 100644
--- a/narwhals/_dask/namespace.py
+++ b/narwhals/_dask/namespace.py
@@ -17,6 +17,7 @@ from narwhals._dask.utils import narwhals_to_native_dtype
 from narwhals._dask.utils import validate_comparand
 from narwhals._expression_parsing import combine_root_names
 from narwhals._expression_parsing import parse_into_exprs
+from narwhals._expression_parsing import reduce_output_names
 
 if TYPE_CHECKING:
     import dask_expr
@@ -155,9 +156,7 @@ class DaskNamespace:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: DaskLazyFrame) -> list[dask_expr.Series]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = [s for _expr in parsed_exprs for s in _expr._call(df)]
             return [reduce(lambda x, y: x & y, series).rename(series[0].name)]
 
         return DaskExpr(
@@ -165,7 +164,7 @@ class DaskNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="all_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
             returns_scalar=False,
             backend_version=self._backend_version,
         )
@@ -174,9 +173,7 @@ class DaskNamespace:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: DaskLazyFrame) -> list[dask_expr.Series]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = [s for _expr in parsed_exprs for s in _expr._call(df)]
             return [reduce(lambda x, y: x | y, series).rename(series[0].name)]
 
         return DaskExpr(
@@ -184,7 +181,7 @@ class DaskNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="any_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
             returns_scalar=False,
             backend_version=self._backend_version,
         )
@@ -193,9 +190,7 @@ class DaskNamespace:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: DaskLazyFrame) -> list[dask_expr.Series]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend([_series.fillna(0) for _series in _expr._call(df)])
+            series = [s.fillna(0) for _expr in parsed_exprs for s in _expr._call(df)]
             return [reduce(lambda x, y: x + y, series).rename(series[0].name)]
 
         return DaskExpr(
@@ -203,7 +198,7 @@ class DaskNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="sum_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
             returns_scalar=False,
             backend_version=self._backend_version,
         )
diff --git a/narwhals/_expression_parsing.py b/narwhals/_expression_parsing.py
index 35d0f7ec..d281cc94 100644
--- a/narwhals/_expression_parsing.py
+++ b/narwhals/_expression_parsing.py
@@ -319,3 +319,12 @@ def combine_root_names(parsed_exprs: Sequence[CompliantExpr]) -> list[str] | Non
                 root_names = None
                 break
     return root_names
+
+
+def reduce_output_names(parsed_exprs: Sequence[CompliantExpr]) -> list[str] | None:
+    """Returns the left-most output name"""
+    return (
+        parsed_exprs[0]._output_names[:1]
+        if parsed_exprs[0]._output_names is not None
+        else None
+    )
diff --git a/narwhals/_pandas_like/dataframe.py b/narwhals/_pandas_like/dataframe.py
index b77d169d..47a6bb39 100644
--- a/narwhals/_pandas_like/dataframe.py
+++ b/narwhals/_pandas_like/dataframe.py
@@ -14,7 +14,7 @@ from narwhals._pandas_like.utils import broadcast_series
 from narwhals._pandas_like.utils import convert_str_slice_to_int_slice
 from narwhals._pandas_like.utils import create_native_series
 from narwhals._pandas_like.utils import horizontal_concat
-from narwhals._pandas_like.utils import translate_dtype
+from narwhals._pandas_like.utils import native_to_narwhals_dtype
 from narwhals._pandas_like.utils import validate_dataframe_comparand
 from narwhals.dependencies import is_numpy_array
 from narwhals.utils import Implementation
@@ -265,7 +265,7 @@ class PandasLikeDataFrame:
     @property
     def schema(self) -> dict[str, DType]:
         return {
-            col: translate_dtype(self._native_frame.loc[:, col])
+            col: native_to_narwhals_dtype(self._native_frame.loc[:, col])
             for col in self._native_frame.columns
         }
 
diff --git a/narwhals/_pandas_like/namespace.py b/narwhals/_pandas_like/namespace.py
index 357ef80a..7356524d 100644
--- a/narwhals/_pandas_like/namespace.py
+++ b/narwhals/_pandas_like/namespace.py
@@ -11,6 +11,7 @@ from typing import cast
 from narwhals import dtypes
 from narwhals._expression_parsing import combine_root_names
 from narwhals._expression_parsing import parse_into_exprs
+from narwhals._expression_parsing import reduce_output_names
 from narwhals._pandas_like.dataframe import PandasLikeDataFrame
 from narwhals._pandas_like.expr import PandasLikeExpr
 from narwhals._pandas_like.selectors import PandasSelectorNamespace
@@ -218,9 +219,7 @@ class PandasLikeNamespace:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend([_series.fill_null(0) for _series in _expr._call(df)])
+            series = (s.fill_null(0) for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x + y, series)]
 
         return self._create_expr_from_callable(
@@ -228,16 +227,14 @@ class PandasLikeNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="sum_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def all_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = (s for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x & y, series)]
 
         return self._create_expr_from_callable(
@@ -245,16 +242,14 @@ class PandasLikeNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="all_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def any_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
         parsed_exprs = parse_into_exprs(*exprs, namespace=self)
 
         def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
-            series = []
-            for _expr in parsed_exprs:
-                series.extend(list(_expr._call(df)))
+            series = (s for _expr in parsed_exprs for s in _expr._call(df))
             return [reduce(lambda x, y: x | y, series)]
 
         return self._create_expr_from_callable(
@@ -262,7 +257,7 @@ class PandasLikeNamespace:
             depth=max(x._depth for x in parsed_exprs) + 1,
             function_name="any_horizontal",
             root_names=combine_root_names(parsed_exprs),
-            output_names=parsed_exprs[0]._output_names,
+            output_names=reduce_output_names(parsed_exprs),
         )
 
     def mean_horizontal(self, *exprs: IntoPandasLikeExpr) -> PandasLikeExpr:
diff --git a/narwhals/_pandas_like/series.py b/narwhals/_pandas_like/series.py
index d531b464..8557f8ee 100644
--- a/narwhals/_pandas_like/series.py
+++ b/narwhals/_pandas_like/series.py
@@ -11,9 +11,9 @@ from typing import overload
 from narwhals._pandas_like.utils import int_dtype_mapper
 from narwhals._pandas_like.utils import narwhals_to_native_dtype
 from narwhals._pandas_like.utils import native_series_from_iterable
+from narwhals._pandas_like.utils import native_to_narwhals_dtype
 from narwhals._pandas_like.utils import set_axis
 from narwhals._pandas_like.utils import to_datetime
-from narwhals._pandas_like.utils import translate_dtype
 from narwhals._pandas_like.utils import validate_column_comparand
 from narwhals.utils import Implementation
 
@@ -167,7 +167,7 @@ class PandasLikeSeries:
 
     @property
     def dtype(self: Self) -> DType:
-        return translate_dtype(self._native_series)
+        return native_to_narwhals_dtype(self._native_series)
 
     def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
         if isinstance(values, self.__class__):
diff --git a/narwhals/_pandas_like/utils.py b/narwhals/_pandas_like/utils.py
index 5745ffd8..286d712b 100644
--- a/narwhals/_pandas_like/utils.py
+++ b/narwhals/_pandas_like/utils.py
@@ -206,7 +206,7 @@ def set_axis(
     return obj.set_axis(index, axis=0, **kwargs)  # type: ignore[attr-defined, no-any-return]
 
 
-def translate_dtype(column: Any) -> DType:
+def native_to_narwhals_dtype(column: Any) -> DType:
     from narwhals import dtypes
 
     dtype = str(column.dtype)
diff --git a/narwhals/_polars/dataframe.py b/narwhals/_polars/dataframe.py
index 0a635881..acf70778 100644
--- a/narwhals/_polars/dataframe.py
+++ b/narwhals/_polars/dataframe.py
@@ -6,7 +6,7 @@ from typing import Any
 from narwhals._polars.namespace import PolarsNamespace
 from narwhals._polars.utils import convert_str_slice_to_int_slice
 from narwhals._polars.utils import extract_args_kwargs
-from narwhals._polars.utils import translate_dtype
+from narwhals._polars.utils import native_to_narwhals_dtype
 from narwhals.utils import Implementation
 from narwhals.utils import is_sequence_but_not_str
 from narwhals.utils import parse_columns_to_drop
@@ -78,14 +78,14 @@ class PolarsDataFrame:
     @property
     def schema(self) -> dict[str, Any]:
         schema = self._native_frame.schema
-        return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+        return {name: native_to_narwhals_dtype(dtype) for name, dtype in schema.items()}
 
     def collect_schema(self) -> dict[str, Any]:
         if self._backend_version < (1,):  # pragma: no cover
             schema = self._native_frame.schema
         else:
             schema = dict(self._native_frame.collect_schema())
-        return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+        return {name: native_to_narwhals_dtype(dtype) for name, dtype in schema.items()}
 
     @property
     def shape(self) -> tuple[int, int]:
@@ -257,14 +257,14 @@ class PolarsLazyFrame:
     @property
     def schema(self) -> dict[str, Any]:
         schema = self._native_frame.schema
-        return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+        return {name: native_to_narwhals_dtype(dtype) for name, dtype in schema.items()}
 
     def collect_schema(self) -> dict[str, Any]:
         if self._backend_version < (1,):  # pragma: no cover
             schema = self._native_frame.schema
         else:
             schema = dict(self._native_frame.collect_schema())
-        return {name: translate_dtype(dtype) for name, dtype in schema.items()}
+        return {name: native_to_narwhals_dtype(dtype) for name, dtype in schema.items()}
 
     def collect(self) -> PolarsDataFrame:
         return PolarsDataFrame(
diff --git a/narwhals/_polars/series.py b/narwhals/_polars/series.py
index e8fa2819..7f7bf94a 100644
--- a/narwhals/_polars/series.py
+++ b/narwhals/_polars/series.py
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
     from narwhals.dtypes import DType
 
 from narwhals._polars.utils import narwhals_to_native_dtype
-from narwhals._polars.utils import translate_dtype
+from narwhals._polars.utils import native_to_narwhals_dtype
 
 
 class PolarsSeries:
@@ -81,7 +81,7 @@ class PolarsSeries:
 
     @property
     def dtype(self: Self) -> DType:
-        return translate_dtype(self._native_series.dtype)
+        return native_to_narwhals_dtype(self._native_series.dtype)
 
     @overload
     def __getitem__(self, item: int) -> Any: ...
diff --git a/narwhals/_polars/utils.py b/narwhals/_polars/utils.py
index 4a9809fc..45c464e5 100644
--- a/narwhals/_polars/utils.py
+++ b/narwhals/_polars/utils.py
@@ -26,7 +26,7 @@ def extract_args_kwargs(args: Any, kwargs: Any) -> tuple[list[Any], dict[str, An
     return args, kwargs
 
 
-def translate_dtype(dtype: Any) -> dtypes.DType:
+def native_to_narwhals_dtype(dtype: Any) -> dtypes.DType:
     import polars as pl  # ignore-banned-import()
 
     if dtype == pl.Float64:
diff --git a/narwhals/dataframe.py b/narwhals/dataframe.py
index 86e15732..04a48370 100644
--- a/narwhals/dataframe.py
+++ b/narwhals/dataframe.py
@@ -107,12 +107,6 @@ class BaseFrame(Generic[FrameT]):
     def columns(self) -> list[str]:
         return self._compliant_frame.columns  # type: ignore[no-any-return]
 
-    def lazy(self) -> LazyFrame[Any]:
-        return LazyFrame(
-            self._compliant_frame.lazy(),
-            level=self._level,
-        )
-
     def with_columns(
         self, *exprs: IntoExpr | Iterable[IntoExpr], **named_exprs: IntoExpr
     ) -> Self:
@@ -318,6 +312,16 @@ class DataFrame(BaseFrame[FrameT]):
     `narwhals.from_native`.
     """
 
+    @property
+    def _series(self) -> type[Series]:
+        from narwhals.series import Series
+
+        return Series
+
+    @property
+    def _lazyframe(self) -> type[LazyFrame[Any]]:
+        return LazyFrame
+
     def __init__(
         self,
         df: Any,
@@ -382,14 +386,16 @@ class DataFrame(BaseFrame[FrameT]):
         If a library does not support lazy execution, then this is a no-op.
 
         Examples:
-            Construct pandas and Polars DataFrames:
+            Construct pandas, Polars and PyArrow DataFrames:
 
             >>> import pandas as pd
             >>> import polars as pl
+            >>> import pyarrow as pa
             >>> import narwhals as nw
             >>> df = {"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0], "ham": ["a", "b", "c"]}
             >>> df_pd = pd.DataFrame(df)
             >>> df_pl = pl.DataFrame(df)
+            >>> df_pa = pa.table(df)
 
             We define a library agnostic function:
 
@@ -397,7 +403,7 @@ class DataFrame(BaseFrame[FrameT]):
             ... def func(df):
             ...     return df.lazy()
 
-            Note that then, pandas dataframe stay eager, but Polars DataFrame becomes a Polars LazyFrame:
+            Note that then, pandas and pyarrow dataframe stay eager, but Polars DataFrame becomes a Polars LazyFrame:
 
             >>> func(df_pd)
                foo  bar ham
@@ -406,8 +412,17 @@ class DataFrame(BaseFrame[FrameT]):
             2    3  8.0   c
             >>> func(df_pl)
             <LazyFrame ...>
+            >>> func(df_pa)
+            pyarrow.Table
+            foo: int64
+            bar: double
+            ham: string
+            ----
+            foo: [[1,2,3]]
+            bar: [[6,7,8]]
+            ham: [["a","b","c"]]
         """
-        return super().lazy()
+        return self._lazyframe(self._compliant_frame.lazy(), level=self._level)
 
     def to_native(self) -> FrameT:
         """
@@ -667,9 +682,7 @@ class DataFrame(BaseFrame[FrameT]):
                 2
             ]
         """
-        from narwhals.series import Series
-
-        return Series(
+        return self._series(
             self._compliant_frame.get_column(name),
             level=self._level,
         )
@@ -819,9 +832,7 @@ class DataFrame(BaseFrame[FrameT]):
                 return self._from_compliant_dataframe(self._compliant_frame[item[0]])
             return self._from_compliant_dataframe(self._compliant_frame[item])
         if isinstance(item, str) or (isinstance(item, tuple) and len(item) == 2):
-            from narwhals.series import Series
-
-            return Series(
+            return self._series(
                 self._compliant_frame[item],
                 level=self._level,
             )
@@ -887,11 +898,9 @@ class DataFrame(BaseFrame[FrameT]):
             >>> func(df_pa)
             {'A': [1, 2, 3, 4, 5], 'fruits': ['banana', 'banana', 'apple', 'apple', 'banana'], 'B': [5, 4, 3, 2, 1], 'animals': ['beetle', 'fly', 'beetle', 'beetle', 'beetle'], 'optional': [28, 300, None, 2, -30]}
         """
-        from narwhals.series import Series
-
         if as_series:
             return {
-                key: Series(
+                key: self._series(
                     value,
                     level=self._level,
                 )
@@ -2287,9 +2296,7 @@ class DataFrame(BaseFrame[FrameT]):
                 true
             ]
         """
-        from narwhals.series import Series
-
-        return Series(
+        return self._series(
             self._compliant_frame.is_duplicated(),
             level=self._level,
         )
@@ -2370,9 +2377,7 @@ class DataFrame(BaseFrame[FrameT]):
                 false
             ]
         """
-        from narwhals.series import Series
-
-        return Series(
+        return self._series(
             self._compliant_frame.is_unique(),
             level=self._level,
         )
@@ -2732,6 +2737,10 @@ class LazyFrame(BaseFrame[FrameT]):
     `narwhals.from_native`.
     """
 
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
     def __init__(
         self,
         df: Any,
@@ -2799,7 +2808,7 @@ class LazyFrame(BaseFrame[FrameT]):
             │ c   ┆ 6   ┆ 1   │
             └─────┴─────┴─────┘
         """
-        return DataFrame(
+        return self._dataframe(
             self._compliant_frame.collect(),
             level=self._level,
         )
@@ -4222,7 +4231,7 @@ class LazyFrame(BaseFrame[FrameT]):
             >>> func(df_pl)
             <LazyFrame ...>
         """
-        return super().lazy()  # type: ignore[return-value]
+        return self
 
     def gather_every(self: Self, n: int, offset: int = 0) -> Self:
         r"""
diff --git a/narwhals/series.py b/narwhals/series.py
index bd99fc5c..5a84a9a5 100644
--- a/narwhals/series.py
+++ b/narwhals/series.py
@@ -33,6 +33,12 @@ class Series:
     `series_only=True`.
     """
 
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        from narwhals.dataframe import DataFrame
+
+        return DataFrame
+
     def __init__(
         self,
         series: Any,
@@ -440,9 +446,7 @@ class Series:
             │ 3   │
             └─────┘
         """
-        from narwhals.dataframe import DataFrame
-
-        return DataFrame(
+        return self._dataframe(
             self._compliant_series.to_frame(),
             level=self._level,
         )
@@ -2021,9 +2025,7 @@ class Series:
             │ 3   ┆ 1     │
             └─────┴───────┘
         """
-        from narwhals.dataframe import DataFrame
-
-        return DataFrame(
+        return self._dataframe(
             self._compliant_series.value_counts(
                 sort=sort, parallel=parallel, name=name, normalize=normalize
             ),
@@ -2350,9 +2352,7 @@ class Series:
             │ 0   ┆ 1   │
             └─────┴─────┘
         """
-        from narwhals.dataframe import DataFrame
-
-        return DataFrame(
+        return self._dataframe(
             self._compliant_series.to_dummies(separator=separator, drop_first=drop_first),
             level=self._level,
         )
diff --git a/narwhals/stable/v1.py b/narwhals/stable/v1/__init__.py
similarity index 94%
rename from narwhals/stable/v1.py
rename to narwhals/stable/v1/__init__.py
index b54203ca..8c4bd877 100644
--- a/narwhals/stable/v1.py
+++ b/narwhals/stable/v1/__init__.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from functools import wraps
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Callable
@@ -44,7 +45,6 @@ from narwhals.functions import show_versions
 from narwhals.schema import Schema as NwSchema
 from narwhals.series import Series as NwSeries
 from narwhals.translate import get_native_namespace as nw_get_native_namespace
-from narwhals.translate import narwhalify as nw_narwhalify
 from narwhals.translate import to_native
 from narwhals.typing import IntoDataFrameT
 from narwhals.typing import IntoFrameT
@@ -75,6 +75,17 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
     `narwhals.from_native`.
     """
 
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @property
+    def _series(self) -> type[Series]:
+        return Series
+
+    @property
+    def _lazyframe(self) -> type[LazyFrame[Any]]:
+        return LazyFrame
+
     @overload
     def __getitem__(self, item: tuple[Sequence[int], slice]) -> Self: ...
     @overload
@@ -110,7 +121,7 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
     def __getitem__(self, item: tuple[slice, slice]) -> Self: ...
 
     def __getitem__(self, item: Any) -> Any:
-        return _stableify(super().__getitem__(item))
+        return super().__getitem__(item)
 
     def lazy(self) -> LazyFrame[Any]:
         """
@@ -119,14 +130,16 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
         If a library does not support lazy execution, then this is a no-op.
 
         Examples:
-            Construct pandas and Polars DataFrames:
+            Construct pandas, Polars and PyArrow DataFrames:
 
             >>> import pandas as pd
             >>> import polars as pl
+            >>> import pyarrow as pa
             >>> import narwhals.stable.v1 as nw
             >>> df = {"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0], "ham": ["a", "b", "c"]}
             >>> df_pd = pd.DataFrame(df)
             >>> df_pl = pl.DataFrame(df)
+            >>> df_pa = pa.table(df)
 
             We define a library agnostic function:
 
@@ -134,7 +147,7 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
             ... def func(df):
             ...     return df.lazy()
 
-            Note that then, pandas dataframe stay eager, but Polars DataFrame becomes a Polars LazyFrame:
+            Note that then, pandas and pyarrow dataframe stay eager, but Polars DataFrame becomes a Polars LazyFrame:
 
             >>> func(df_pd)
                foo  bar ham
@@ -143,8 +156,17 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
             2    3  8.0   c
             >>> func(df_pl)
             <LazyFrame ...>
+            >>> func(df_pa)
+            pyarrow.Table
+            foo: int64
+            bar: double
+            ham: string
+            ----
+            foo: [[1,2,3]]
+            bar: [[6,7,8]]
+            ham: [["a","b","c"]]
         """
-        return _stableify(super().lazy())  # type: ignore[no-any-return]
+        return super().lazy()  # type: ignore[return-value]
 
     # Not sure what mypy is complaining about, probably some fancy
     # thing that I need to understand category theory for
@@ -195,9 +217,7 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
             >>> func(df_pa)
             {'A': [1, 2, 3, 4, 5], 'fruits': ['banana', 'banana', 'apple', 'apple', 'banana'], 'B': [5, 4, 3, 2, 1], 'animals': ['beetle', 'fly', 'beetle', 'beetle', 'beetle'], 'optional': [28, 300, None, 2, -30]}
         """
-        if as_series:
-            return {key: _stableify(value) for key, value in super().to_dict().items()}
-        return super().to_dict(as_series=False)
+        return super().to_dict(as_series=as_series)  # type: ignore[return-value]
 
     def is_duplicated(self: Self) -> Series:
         r"""
@@ -245,7 +265,7 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
                 true
             ]
         """
-        return _stableify(super().is_duplicated())
+        return super().is_duplicated()  # type: ignore[return-value]
 
     def is_unique(self: Self) -> Series:
         r"""
@@ -293,7 +313,11 @@ class DataFrame(NwDataFrame[IntoDataFrameT]):
                 false
             ]
         """
-        return _stableify(super().is_unique())
+        return super().is_unique()  # type: ignore[return-value]
+
+    def _l1_norm(self: Self) -> Self:
+        """Private, just used to test the stable API."""
+        return self.select(all()._l1_norm())
 
 
 class LazyFrame(NwLazyFrame[IntoFrameT]):
@@ -306,6 +330,10 @@ class LazyFrame(NwLazyFrame[IntoFrameT]):
     `narwhals.from_native`.
     """
 
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
     def collect(self) -> DataFrame[Any]:
         r"""
         Materialize this LazyFrame into a DataFrame.
@@ -342,7 +370,11 @@ class LazyFrame(NwLazyFrame[IntoFrameT]):
             │ c   ┆ 6   ┆ 1   │
             └─────┴─────┴─────┘
         """
-        return _stableify(super().collect())  # type: ignore[no-any-return]
+        return super().collect()  # type: ignore[return-value]
+
+    def _l1_norm(self: Self) -> Self:
+        """Private, just used to test the stable API."""
+        return self.select(all()._l1_norm())
 
 
 class Series(NwSeries):
@@ -356,6 +388,13 @@ class Series(NwSeries):
     `series_only=True`.
     """
 
+    # We need to override any method which don't return Self so that type
+    # annotations are correct.
+
+    @property
+    def _dataframe(self) -> type[DataFrame[Any]]:
+        return DataFrame
+
     def to_frame(self) -> DataFrame[Any]:
         """
         Convert to dataframe.
@@ -393,7 +432,7 @@ class Series(NwSeries):
             │ 3   │
             └─────┘
         """
-        return _stableify(super().to_frame())  # type: ignore[no-any-return]
+        return super().to_frame()  # type: ignore[return-value]
 
     def value_counts(
         self: Self,
@@ -447,10 +486,8 @@ class Series(NwSeries):
             │ 3   ┆ 1     │
             └─────┴───────┘
         """
-        return _stableify(  # type: ignore[no-any-return]
-            super().value_counts(
-                sort=sort, parallel=parallel, name=name, normalize=normalize
-            )
+        return super().value_counts(  # type: ignore[return-value]
+            sort=sort, parallel=parallel, name=name, normalize=normalize
         )
 
 
@@ -854,14 +891,54 @@ def narwhalify(
         allow_series: Whether to allow series (default is only dataframe / lazyframe).
     """
 
-    return nw_narwhalify(
-        func=func,
-        strict=strict,
-        eager_only=eager_only,
-        eager_or_interchange_only=eager_or_interchange_only,
-        series_only=series_only,
-        allow_series=allow_series,
-    )
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            args = [
+                from_native(
+                    arg,
+                    strict=strict,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for arg in args
+            ]  # type: ignore[assignment]
+
+            kwargs = {
+                name: from_native(
+                    value,
+                    strict=strict,
+                    eager_only=eager_only,
+                    eager_or_interchange_only=eager_or_interchange_only,
+                    series_only=series_only,
+                    allow_series=allow_series,
+                )
+                for name, value in kwargs.items()
+            }
+
+            backends = {
+                b()
+                for v in (*args, *kwargs.values())
+                if (b := getattr(v, "__native_namespace__", None))
+            }
+
+            if backends.__len__() > 1:
+                msg = "Found multiple backends. Make sure that all dataframe/series inputs come from the same backend."
+                raise ValueError(msg)
+
+            result = func(*args, **kwargs)
+
+            return to_native(result, strict=strict)
+
+        return wrapper
+
+    if func is None:
+        return decorator
+    else:
+        # If func is not None, it means the decorator is used without arguments
+        return decorator(func)
 
 
 def all() -> Expr:


Test patch:
diff --git a/tests/frame/drop_nulls_test.py b/tests/frame/drop_nulls_test.py
index 4c227603..9988aa6b 100644
--- a/tests/frame/drop_nulls_test.py
+++ b/tests/frame/drop_nulls_test.py
@@ -21,11 +21,16 @@ def test_drop_nulls(constructor: Constructor) -> None:
     compare_dicts(result, expected)
 
 
-@pytest.mark.parametrize("subset", ["a", ["a"]])
-def test_drop_nulls_subset(constructor: Constructor, subset: str | list[str]) -> None:
+@pytest.mark.parametrize(
+    ("subset", "expected"),
+    [
+        ("a", {"a": [1, 2.0, 4.0], "b": [float("nan"), 3.0, 5.0]}),
+        (["a"], {"a": [1, 2.0, 4.0], "b": [float("nan"), 3.0, 5.0]}),
+        (["a", "b"], {"a": [2.0, 4.0], "b": [3.0, 5.0]}),
+    ],
+)
+def test_drop_nulls_subset(
+    constructor: Constructor, subset: str | list[str], expected: dict[str, float]
+) -> None:
     result = nw.from_native(constructor(data)).drop_nulls(subset=subset)
-    expected = {
-        "a": [1, 2.0, 4.0],
-        "b": [float("nan"), 3.0, 5.0],
-    }
     compare_dicts(result, expected)
diff --git a/tests/frame/lazy_test.py b/tests/frame/lazy_test.py
index 14b9d148..09ca734c 100644
--- a/tests/frame/lazy_test.py
+++ b/tests/frame/lazy_test.py
@@ -1,9 +1,13 @@
 from typing import Any
 
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 
 
 def test_lazy(constructor_eager: Any) -> None:
     df = nw.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
     result = df.lazy()
     assert isinstance(result, nw.LazyFrame)
+    df = nw_v1.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
+    result = df.lazy()
+    assert isinstance(result, nw_v1.LazyFrame)
diff --git a/tests/stable_api_test.py b/tests/stable_api_test.py
index 375af4f4..d579b818 100644
--- a/tests/stable_api_test.py
+++ b/tests/stable_api_test.py
@@ -1,3 +1,5 @@
+from typing import Any
+
 import polars as pl
 import pytest
 
@@ -36,6 +38,33 @@ def test_renamed_taxicab_norm(constructor: Constructor) -> None:
     compare_dicts(result, expected)
 
 
+def test_renamed_taxicab_norm_dataframe(constructor: Constructor) -> None:
+    # Suppose we have `DataFrame._l1_norm` in `stable.v1`, but remove it
+    # in the main namespace. Here, we check that it's still usable from
+    # the stable api.
+    def func(df_any: Any) -> Any:
+        df = nw_v1.from_native(df_any)
+        df = df._l1_norm()
+        return df.to_native()
+
+    result = nw_v1.from_native(func(constructor({"a": [1, 2, 3, -4, 5]})))
+    expected = {"a": [15]}
+    compare_dicts(result, expected)
+
+
+def test_renamed_taxicab_norm_dataframe_narwhalify(constructor: Constructor) -> None:
+    # Suppose we have `DataFrame._l1_norm` in `stable.v1`, but remove it
+    # in the main namespace. Here, we check that it's still usable from
+    # the stable api when using `narwhalify`.
+    @nw_v1.narwhalify
+    def func(df: Any) -> Any:
+        return df._l1_norm()
+
+    result = nw_v1.from_native(func(constructor({"a": [1, 2, 3, -4, 5]})))
+    expected = {"a": [15]}
+    compare_dicts(result, expected)
+
+
 def test_stable_api_completeness() -> None:
     v_1_api = nw_v1.__all__
     main_namespace_api = nw.__all__