Repository: narwhals-dev/narwhals
Pull request #2379 (2025-04-12 15:44:33)

chore: use nw_v1 / nw naming consistently in tests
Towards v2

The idea is:
- in tests which use both `v1` and main APIs, alias the v1 one to `nw_v1`

Later:
- always use the main API for tests
- make separate `v1_test.py` and `v2_test.py` which test methods which we overwrite from the stable apis 

<!--
# 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
- [ ] 📝 Documentation
- [ ] ✅ Test
- [ ] 🐳 Other

## Related issues

- Related issue #\<issue number\>
- Closes #\<issue number\>

## 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/narwhals/_compliant/expr.py b/narwhals/_compliant/expr.py
index 9ae4b663..2f30c96b 100644
--- a/narwhals/_compliant/expr.py
+++ b/narwhals/_compliant/expr.py
@@ -37,7 +37,6 @@ from narwhals.dtypes import DType
 from narwhals.utils import _StoresCompliant
 from narwhals.utils import deprecated
 from narwhals.utils import not_implemented
-from narwhals.utils import unstable
 
 if not TYPE_CHECKING:  # pragma: no cover
     if sys.version_info >= (3, 9):
@@ -197,7 +196,6 @@ class CompliantExpr(Protocol38[CompliantFrameT, CompliantSeriesOrNativeExprT_co]
     @property
     def struct(self) -> Any: ...
 
-    @unstable
     def ewm_mean(
         self,
         *,
@@ -210,7 +208,6 @@ class CompliantExpr(Protocol38[CompliantFrameT, CompliantSeriesOrNativeExprT_co]
         ignore_nulls: bool,
     ) -> Self: ...
 
-    @unstable
     def rolling_sum(
         self,
         window_size: int,
@@ -219,7 +216,6 @@ class CompliantExpr(Protocol38[CompliantFrameT, CompliantSeriesOrNativeExprT_co]
         center: bool,
     ) -> Self: ...
 
-    @unstable
     def rolling_mean(
         self,
         window_size: int,
@@ -228,7 +224,6 @@ class CompliantExpr(Protocol38[CompliantFrameT, CompliantSeriesOrNativeExprT_co]
         center: bool,
     ) -> Self: ...
 
-    @unstable
     def rolling_var(
         self,
         window_size: int,
@@ -238,7 +233,6 @@ class CompliantExpr(Protocol38[CompliantFrameT, CompliantSeriesOrNativeExprT_co]
         ddof: int,
     ) -> Self: ...
 
-    @unstable
     def rolling_std(
         self,
         window_size: int,
diff --git a/narwhals/_compliant/series.py b/narwhals/_compliant/series.py
index 5ebcb80c..28083829 100644
--- a/narwhals/_compliant/series.py
+++ b/narwhals/_compliant/series.py
@@ -142,7 +142,6 @@ class CompliantSeries(
     def cum_sum(self, *, reverse: bool) -> Self: ...
     def diff(self) -> Self: ...
     def drop_nulls(self) -> Self: ...
-    @unstable
     def ewm_mean(
         self,
         *,
@@ -199,7 +198,6 @@ class CompliantSeries(
         *,
         return_dtype: DType | type[DType] | None,
     ) -> Self: ...
-    @unstable
     def rolling_mean(
         self,
         window_size: int,
@@ -207,7 +205,6 @@ class CompliantSeries(
         min_samples: int,
         center: bool,
     ) -> Self: ...
-    @unstable
     def rolling_std(
         self,
         window_size: int,
@@ -216,7 +213,6 @@ class CompliantSeries(
         center: bool,
         ddof: int,
     ) -> Self: ...
-    @unstable
     def rolling_sum(
         self,
         window_size: int,
@@ -224,7 +220,6 @@ class CompliantSeries(
         min_samples: int,
         center: bool,
     ) -> Self: ...
-    @unstable
     def rolling_var(
         self,
         window_size: int,
diff --git a/narwhals/expr.py b/narwhals/expr.py
index 49c80f31..fade3eb1 100644
--- a/narwhals/expr.py
+++ b/narwhals/expr.py
@@ -453,10 +453,6 @@ class Expr:
     ) -> Self:
         r"""Compute exponentially-weighted moving average.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         Arguments:
             com: Specify decay in terms of center of mass, $\gamma$, with <br> $\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$
             span: Specify decay in terms of span, $\theta$, with <br> $\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$
@@ -2210,10 +2206,6 @@ class Expr:
     ) -> Self:
         """Apply a rolling sum (moving sum) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their sum.
 
@@ -2276,10 +2268,6 @@ class Expr:
     ) -> Self:
         """Apply a rolling mean (moving mean) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their mean.
 
@@ -2343,10 +2331,6 @@ class Expr:
     ) -> Self:
         """Apply a rolling variance (moving variance) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their variance.
 
@@ -2409,10 +2393,6 @@ class Expr:
     ) -> Self:
         """Apply a rolling standard deviation (moving standard deviation) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their standard deviation.
 
diff --git a/narwhals/series.py b/narwhals/series.py
index c3a57795..4073ec84 100644
--- a/narwhals/series.py
+++ b/narwhals/series.py
@@ -394,10 +394,6 @@ class Series(Generic[IntoSeriesT]):
     ) -> Self:
         r"""Compute exponentially-weighted moving average.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         Arguments:
             com: Specify decay in terms of center of mass, $\gamma$, with <br> $\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$
             span: Specify decay in terms of span, $\theta$, with <br> $\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$
@@ -2246,10 +2242,6 @@ class Series(Generic[IntoSeriesT]):
     ) -> Self:
         """Apply a rolling sum (moving sum) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their sum.
 
@@ -2304,10 +2296,6 @@ class Series(Generic[IntoSeriesT]):
     ) -> Self:
         """Apply a rolling mean (moving mean) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their mean.
 
@@ -2367,10 +2355,6 @@ class Series(Generic[IntoSeriesT]):
     ) -> Self:
         """Apply a rolling variance (moving variance) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their variance.
 
@@ -2430,10 +2414,6 @@ class Series(Generic[IntoSeriesT]):
     ) -> Self:
         """Apply a rolling standard deviation (moving standard deviation) over the values.
 
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
         A window of length `window_size` will traverse the values. The resulting values
         will be aggregated to their standard deviation.
 
diff --git a/narwhals/stable/v1/__init__.py b/narwhals/stable/v1/__init__.py
index 92245b26..ea310d8a 100644
--- a/narwhals/stable/v1/__init__.py
+++ b/narwhals/stable/v1/__init__.py
@@ -437,262 +437,6 @@ class Series(NwSeries[IntoSeriesT]):
             sort=sort, parallel=parallel, name=name, normalize=normalize
         )
 
-    def ewm_mean(
-        self: Self,
-        *,
-        com: float | None = None,
-        span: float | None = None,
-        half_life: float | None = None,
-        alpha: float | None = None,
-        adjust: bool = True,
-        min_samples: int = 1,
-        ignore_nulls: bool = False,
-    ) -> Self:
-        r"""Compute exponentially-weighted moving average.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        Arguments:
-            com: Specify decay in terms of center of mass, $\gamma$, with <br> $\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$
-            span: Specify decay in terms of span, $\theta$, with <br> $\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$
-            half_life: Specify decay in terms of half-life, $\tau$, with <br> $\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \forall \tau > 0$
-            alpha: Specify smoothing factor alpha directly, $0 < \alpha \leq 1$.
-            adjust: Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings
-
-                - When `adjust=True` (the default) the EW function is calculated
-                  using weights $w_i = (1 - \alpha)^i$
-                - When `adjust=False` the EW function is calculated recursively by
-                  $$
-                  y_0=x_0
-                  $$
-                  $$
-                  y_t = (1 - \alpha)y_{t - 1} + \alpha x_t
-                  $$
-            min_samples: Minimum number of observations in window required to have a value (otherwise result is null).
-            ignore_nulls: Ignore missing values when calculating weights.
-
-                - When `ignore_nulls=False` (default), weights are based on absolute
-                  positions.
-                  For example, the weights of $x_0$ and $x_2$ used in
-                  calculating the final weighted average of $[x_0, None, x_2]$ are
-                  $(1-\alpha)^2$ and $1$ if `adjust=True`, and
-                  $(1-\alpha)^2$ and $\alpha$ if `adjust=False`.
-                - When `ignore_nulls=True`, weights are based
-                  on relative positions. For example, the weights of
-                  $x_0$ and $x_2$ used in calculating the final weighted
-                  average of $[x_0, None, x_2]$ are
-                  $1-\alpha$ and $1$ if `adjust=True`,
-                  and $1-\alpha$ and $\alpha$ if `adjust=False`.
-
-        Returns:
-            Series
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Series.ewm_mean` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().ewm_mean(
-            com=com,
-            span=span,
-            half_life=half_life,
-            alpha=alpha,
-            adjust=adjust,
-            min_samples=min_samples,
-            ignore_nulls=ignore_nulls,
-        )
-
-    def rolling_sum(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-    ) -> Self:
-        """Apply a rolling sum (moving sum) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their sum.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`
-            center: Set the labels at the center of the window.
-
-        Returns:
-            A new series.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Series.rolling_sum` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_sum(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-        )
-
-    def rolling_mean(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-    ) -> Self:
-        """Apply a rolling mean (moving mean) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their mean.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`
-            center: Set the labels at the center of the window.
-
-        Returns:
-            A new series.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Series.rolling_mean` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_mean(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-        )
-
-    def rolling_var(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-        ddof: int = 1,
-    ) -> Self:
-        """Apply a rolling variance (moving variance) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their variance.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`.
-            center: Set the labels at the center of the window.
-            ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof.
-
-        Returns:
-            A new series.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Series.rolling_var` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_var(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-            ddof=ddof,
-        )
-
-    def rolling_std(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-        ddof: int = 1,
-    ) -> Self:
-        """Apply a rolling standard deviation (moving standard deviation) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their standard deviation.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`.
-            center: Set the labels at the center of the window.
-            ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof.
-
-        Returns:
-            A new series.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Series.rolling_std` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_std(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-            ddof=ddof,
-        )
-
     def hist(
         self: Self,
         bins: list[float | int] | None = None,
@@ -733,259 +477,6 @@ class Expr(NwExpr):
     def _l1_norm(self: Self) -> Self:
         return super()._taxicab_norm()
 
-    def ewm_mean(
-        self: Self,
-        *,
-        com: float | None = None,
-        span: float | None = None,
-        half_life: float | None = None,
-        alpha: float | None = None,
-        adjust: bool = True,
-        min_samples: int = 1,
-        ignore_nulls: bool = False,
-    ) -> Self:
-        r"""Compute exponentially-weighted moving average.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        Arguments:
-            com: Specify decay in terms of center of mass, $\gamma$, with <br> $\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$
-            span: Specify decay in terms of span, $\theta$, with <br> $\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$
-            half_life: Specify decay in terms of half-life, $\tau$, with <br> $\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \forall \tau > 0$
-            alpha: Specify smoothing factor alpha directly, $0 < \alpha \leq 1$.
-            adjust: Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings
-
-                - When `adjust=True` (the default) the EW function is calculated
-                  using weights $w_i = (1 - \alpha)^i$
-                - When `adjust=False` the EW function is calculated recursively by
-                  $$
-                  y_0=x_0
-                  $$
-                  $$
-                  y_t = (1 - \alpha)y_{t - 1} + \alpha x_t
-                  $$
-            min_samples: Minimum number of observations in window required to have a value, (otherwise result is null).
-            ignore_nulls: Ignore missing values when calculating weights.
-
-                - When `ignore_nulls=False` (default), weights are based on absolute
-                  positions.
-                  For example, the weights of $x_0$ and $x_2$ used in
-                  calculating the final weighted average of $[x_0, None, x_2]$ are
-                  $(1-\alpha)^2$ and $1$ if `adjust=True`, and
-                  $(1-\alpha)^2$ and $\alpha$ if `adjust=False`.
-                - When `ignore_nulls=True`, weights are based
-                  on relative positions. For example, the weights of
-                  $x_0$ and $x_2$ used in calculating the final weighted
-                  average of $[x_0, None, x_2]$ are
-                  $1-\alpha$ and $1$ if `adjust=True`,
-                  and $1-\alpha$ and $\alpha$ if `adjust=False`.
-
-        Returns:
-            Expr
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Expr.ewm_mean` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().ewm_mean(
-            com=com,
-            span=span,
-            half_life=half_life,
-            alpha=alpha,
-            adjust=adjust,
-            min_samples=min_samples,
-            ignore_nulls=ignore_nulls,
-        )
-
-    def rolling_sum(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-    ) -> Self:
-        """Apply a rolling sum (moving sum) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their sum.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`
-            center: Set the labels at the center of the window.
-
-        Returns:
-            A new expression.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Expr.rolling_sum` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_sum(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-        )
-
-    def rolling_mean(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-    ) -> Self:
-        """Apply a rolling mean (moving mean) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their mean.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`
-            center: Set the labels at the center of the window.
-
-        Returns:
-            A new expression.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Expr.rolling_mean` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_mean(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-        )
-
-    def rolling_var(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-        ddof: int = 1,
-    ) -> Self:
-        """Apply a rolling variance (moving variance) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their variance.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`.
-            center: Set the labels at the center of the window.
-            ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof.
-
-        Returns:
-            A new expression.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Expr.rolling_var` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_var(
-            window_size=window_size, min_samples=min_samples, center=center, ddof=ddof
-        )
-
-    def rolling_std(
-        self: Self,
-        window_size: int,
-        *,
-        min_samples: int | None = None,
-        center: bool = False,
-        ddof: int = 1,
-    ) -> Self:
-        """Apply a rolling standard deviation (moving standard deviation) over the values.
-
-        !!! warning
-            This functionality is considered **unstable**. It may be changed at any point
-            without it being considered a breaking change.
-
-        A window of length `window_size` will traverse the values. The resulting values
-        will be aggregated to their standard deviation.
-
-        The window at a given row will include the row itself and the `window_size - 1`
-        elements before it.
-
-        Arguments:
-            window_size: The length of the window in number of elements. It must be a
-                strictly positive integer.
-            min_samples: The number of values in the window that should be non-null before
-                computing a result. If set to `None` (default), it will be set equal to
-                `window_size`. If provided, it must be a strictly positive integer, and
-                less than or equal to `window_size`
-            center: Set the labels at the center of the window.
-            ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof.
-
-        Returns:
-            A new expression.
-        """
-        from narwhals.exceptions import NarwhalsUnstableWarning
-        from narwhals.utils import find_stacklevel
-
-        msg = (
-            "`Expr.rolling_std` is being called from the stable API although considered "
-            "an unstable feature."
-        )
-        warn(message=msg, category=NarwhalsUnstableWarning, stacklevel=find_stacklevel())
-        return super().rolling_std(
-            window_size=window_size,
-            min_samples=min_samples,
-            center=center,
-            ddof=ddof,
-        )
-
     def head(self: Self, n: int = 10) -> Self:
         r"""Get the first `n` rows.
 


Test patch:
diff --git a/tests/expr_and_series/ewm_test.py b/tests/expr_and_series/ewm_test.py
index 34941c6d..28f35bba 100644
--- a/tests/expr_and_series/ewm_test.py
+++ b/tests/expr_and_series/ewm_test.py
@@ -9,9 +9,6 @@ from tests.utils import assert_equal_data
 data = {"a": [1, 1, 2], "b": [1, 2, 3]}
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 def test_ewm_mean_expr(
     request: pytest.FixtureRequest, constructor_eager: ConstructorEager
 ) -> None:
@@ -27,9 +24,6 @@ def test_ewm_mean_expr(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Series.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 def test_ewm_mean_series(
     request: pytest.FixtureRequest, constructor_eager: ConstructorEager
 ) -> None:
@@ -42,9 +36,6 @@ def test_ewm_mean_series(
     assert_equal_data({"a": result}, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("adjust", "expected"),
     [
@@ -78,9 +69,6 @@ def test_ewm_mean_expr_adjust(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("ignore_nulls", "expected"),
     [
@@ -122,9 +110,6 @@ def test_ewm_mean_nulls(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 def test_ewm_mean_params(
     request: pytest.FixtureRequest,
     constructor_eager: ConstructorEager,
@@ -162,9 +147,6 @@ def test_ewm_mean_params(
         df.select(nw.col("a").ewm_mean(span=1.5, half_life=0.75, ignore_nulls=False))
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.ewm_mean` is being called from the stable API although considered an unstable feature."
-)
 def test_ewm_mean_cudf_raise() -> None:  # pragma: no cover
     pytest.importorskip("cudf")
     import cudf
diff --git a/tests/expr_and_series/gather_every_test.py b/tests/expr_and_series/gather_every_test.py
index 7725b287..47a8bd3c 100644
--- a/tests/expr_and_series/gather_every_test.py
+++ b/tests/expr_and_series/gather_every_test.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
@@ -15,9 +15,9 @@ data = {"a": list(range(10))}
 def test_gather_every_expr(
     constructor_eager: ConstructorEager, n: int, offset: int
 ) -> None:
-    df = nw.from_native(constructor_eager(data))
+    df = nw_v1.from_native(constructor_eager(data))
 
-    result = df.select(nw.col("a").gather_every(n=n, offset=offset))
+    result = df.select(nw_v1.col("a").gather_every(n=n, offset=offset))
     expected = {"a": data["a"][offset::n]}
 
     assert_equal_data(result, expected)
@@ -25,7 +25,7 @@ def test_gather_every_expr(
     with pytest.deprecated_call(
         match="is deprecated and will be removed in a future version"
     ):
-        df.select(nw_main.col("a").gather_every(n=n, offset=offset))
+        df.select(nw.col("a").gather_every(n=n, offset=offset))
 
 
 @pytest.mark.parametrize("n", [1, 2, 3])
@@ -33,7 +33,7 @@ def test_gather_every_expr(
 def test_gather_every_series(
     constructor_eager: ConstructorEager, n: int, offset: int
 ) -> None:
-    series = nw.from_native(constructor_eager(data), eager_only=True)["a"]
+    series = nw_v1.from_native(constructor_eager(data), eager_only=True)["a"]
 
     result = series.gather_every(n=n, offset=offset)
     expected = data["a"][offset::n]
diff --git a/tests/expr_and_series/head_test.py b/tests/expr_and_series/head_test.py
index 8b5af5c7..bf6d4806 100644
--- a/tests/expr_and_series/head_test.py
+++ b/tests/expr_and_series/head_test.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
@@ -14,20 +14,20 @@ def test_head(
 ) -> None:
     if "polars" in str(constructor_eager) and n < 0:
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(constructor_eager({"a": [1, 2, 3]}))
-    result = df.select(nw.col("a").head(n))
+    df = nw_v1.from_native(constructor_eager({"a": [1, 2, 3]}))
+    result = df.select(nw_v1.col("a").head(n))
     expected = {"a": [1, 2]}
     assert_equal_data(result, expected)
 
     with pytest.deprecated_call(
         match="is deprecated and will be removed in a future version"
     ):
-        df.select(nw_main.col("a").head(5))
+        df.select(nw.col("a").head(5))
 
 
 @pytest.mark.parametrize("n", [2, -1])
 def test_head_series(constructor_eager: ConstructorEager, n: int) -> None:
-    df = nw.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
+    df = nw_v1.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
     result = df.select(df["a"].head(n))
     expected = {"a": [1, 2]}
     assert_equal_data(result, expected)
diff --git a/tests/expr_and_series/rolling_mean_test.py b/tests/expr_and_series/rolling_mean_test.py
index 29084ad4..0ff497aa 100644
--- a/tests/expr_and_series/rolling_mean_test.py
+++ b/tests/expr_and_series/rolling_mean_test.py
@@ -40,9 +40,6 @@ kwargs_and_expected: dict[str, dict[str, Any]] = {
 }
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_mean` is being called from the stable API although considered an unstable feature."
-)
 def test_rolling_mean_expr(constructor_eager: ConstructorEager) -> None:
     df = nw.from_native(constructor_eager(data))
     result = df.select(
@@ -100,9 +97,6 @@ def test_rolling_mean_hypothesis(center: bool, values: list[float]) -> None:  #
     assert_equal_data(result, expected_dict)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_mean` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center"),
     [
@@ -158,9 +152,6 @@ def test_rolling_mean_expr_lazy_grouped(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_mean` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center"),
     [
diff --git a/tests/expr_and_series/rolling_std_test.py b/tests/expr_and_series/rolling_std_test.py
index 5f9b5572..95b62692 100644
--- a/tests/expr_and_series/rolling_std_test.py
+++ b/tests/expr_and_series/rolling_std_test.py
@@ -66,9 +66,6 @@ kwargs_and_expected = (
 )
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_std` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize("kwargs_and_expected", kwargs_and_expected)
 def test_rolling_std_expr(
     constructor_eager: ConstructorEager,
@@ -108,9 +105,6 @@ def test_rolling_std_series(
     assert_equal_data(result, {name: expected})
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_std` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center", "ddof"),
     [
@@ -231,9 +225,6 @@ def test_rolling_std_expr_lazy_ungrouped(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_std` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center", "ddof"),
     [
diff --git a/tests/expr_and_series/rolling_sum_test.py b/tests/expr_and_series/rolling_sum_test.py
index d7a040ee..5db870bb 100644
--- a/tests/expr_and_series/rolling_sum_test.py
+++ b/tests/expr_and_series/rolling_sum_test.py
@@ -41,9 +41,6 @@ kwargs_and_expected: dict[str, dict[str, Any]] = {
 }
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_sum` is being called from the stable API although considered an unstable feature."
-)
 def test_rolling_sum_expr(constructor_eager: ConstructorEager) -> None:
     df = nw.from_native(constructor_eager(data))
     result = df.select(
@@ -57,9 +54,6 @@ def test_rolling_sum_expr(constructor_eager: ConstructorEager) -> None:
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_sum` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center"),
     [
@@ -106,9 +100,6 @@ def test_rolling_sum_expr_lazy_ungrouped(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_sum` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center"),
     [
@@ -180,9 +171,6 @@ def test_rolling_sum_series(constructor_eager: ConstructorEager) -> None:
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_sum` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("window_size", "min_samples", "context"),
     [
diff --git a/tests/expr_and_series/rolling_var_test.py b/tests/expr_and_series/rolling_var_test.py
index 46e18216..a708ce8b 100644
--- a/tests/expr_and_series/rolling_var_test.py
+++ b/tests/expr_and_series/rolling_var_test.py
@@ -58,9 +58,6 @@ kwargs_and_expected = (
 )
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_var` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize("kwargs_and_expected", kwargs_and_expected)
 def test_rolling_var_expr(
     request: pytest.FixtureRequest,
@@ -174,9 +171,6 @@ def test_rolling_var_hypothesis_polars(center: bool, values: list[float]) -> Non
     assert_equal_data(result, expected_dict)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_var` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center", "ddof"),
     [
@@ -241,9 +235,6 @@ def test_rolling_var_expr_lazy_ungrouped(
     assert_equal_data(result, expected)
 
 
-@pytest.mark.filterwarnings(
-    "ignore:`Expr.rolling_var` is being called from the stable API although considered an unstable feature."
-)
 @pytest.mark.parametrize(
     ("expected_a", "window_size", "min_samples", "center", "ddof"),
     [
diff --git a/tests/expr_and_series/sample_test.py b/tests/expr_and_series/sample_test.py
index e60142f9..c99657bb 100644
--- a/tests/expr_and_series/sample_test.py
+++ b/tests/expr_and_series/sample_test.py
@@ -2,18 +2,18 @@ from __future__ import annotations
 
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
 
 def test_expr_sample(constructor_eager: ConstructorEager) -> None:
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor_eager({"a": [1, 2, 3], "b": [4, 5, 6]}), eager_only=True
     )
 
-    result_expr = df.select(nw.col("a").sample(n=2)).shape
+    result_expr = df.select(nw_v1.col("a").sample(n=2)).shape
     expected_expr = (2, 1)
     assert result_expr == expected_expr
 
@@ -24,15 +24,15 @@ def test_expr_sample(constructor_eager: ConstructorEager) -> None:
     with pytest.deprecated_call(
         match="is deprecated and will be removed in a future version"
     ):
-        df.select(nw_main.col("a").sample(n=2))
+        df.select(nw.col("a").sample(n=2))
 
 
 def test_expr_sample_fraction(constructor_eager: ConstructorEager) -> None:
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor_eager({"a": [1, 2, 3] * 10, "b": [4, 5, 6] * 10}), eager_only=True
     )
 
-    result_expr = df.select(nw.col("a").sample(fraction=0.1)).shape
+    result_expr = df.select(nw_v1.col("a").sample(fraction=0.1)).shape
     expected_expr = (3, 1)
     assert result_expr == expected_expr
 
@@ -43,15 +43,15 @@ def test_expr_sample_fraction(constructor_eager: ConstructorEager) -> None:
 
 def test_sample_with_seed(constructor_eager: ConstructorEager) -> None:
     size, n = 100, 10
-    df = nw.from_native(constructor_eager({"a": list(range(size))}))
+    df = nw_v1.from_native(constructor_eager({"a": list(range(size))}))
     expected = {"res1": [True], "res2": [False]}
     result = df.select(
-        seed1=nw.col("a").sample(n=n, seed=123),
-        seed2=nw.col("a").sample(n=n, seed=123),
-        seed3=nw.col("a").sample(n=n, seed=42),
+        seed1=nw_v1.col("a").sample(n=n, seed=123),
+        seed2=nw_v1.col("a").sample(n=n, seed=123),
+        seed3=nw_v1.col("a").sample(n=n, seed=42),
     ).select(
-        res1=(nw.col("seed1") == nw.col("seed2")).all(),
-        res2=(nw.col("seed1") == nw.col("seed3")).all(),
+        res1=(nw_v1.col("seed1") == nw_v1.col("seed2")).all(),
+        res2=(nw_v1.col("seed1") == nw_v1.col("seed3")).all(),
     )
 
     assert_equal_data(result, expected)
diff --git a/tests/expr_and_series/sort_test.py b/tests/expr_and_series/sort_test.py
index e3e66592..61424af6 100644
--- a/tests/expr_and_series/sort_test.py
+++ b/tests/expr_and_series/sort_test.py
@@ -4,8 +4,8 @@ from typing import Any
 
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
@@ -24,10 +24,10 @@ data = {"a": [0, 0, 2, -1], "b": [1, 3, 2, None]}
 def test_sort_expr(
     constructor_eager: ConstructorEager, descending: Any, nulls_last: Any, expected: Any
 ) -> None:
-    df = nw.from_native(constructor_eager(data), eager_only=True)
+    df = nw_v1.from_native(constructor_eager(data), eager_only=True)
     result = df.select(
         "a",
-        nw.col("b").sort(descending=descending, nulls_last=nulls_last),
+        nw_v1.col("b").sort(descending=descending, nulls_last=nulls_last),
     )
     assert_equal_data(result, expected)
     with pytest.deprecated_call(
@@ -35,7 +35,7 @@ def test_sort_expr(
     ):
         df.select(
             "a",
-            nw_main.col("b").sort(descending=descending, nulls_last=nulls_last),
+            nw.col("b").sort(descending=descending, nulls_last=nulls_last),
         )
 
 
@@ -51,8 +51,9 @@ def test_sort_expr(
 def test_sort_series(
     constructor_eager: ConstructorEager, descending: Any, nulls_last: Any, expected: Any
 ) -> None:
-    series = nw.from_native(constructor_eager(data), eager_only=True)["b"]
+    series = nw_v1.from_native(constructor_eager(data), eager_only=True)["b"]
     result = series.sort(descending=descending, nulls_last=nulls_last)
     assert (
-        result == nw.from_native(constructor_eager({"a": expected}), eager_only=True)["a"]
+        result
+        == nw_v1.from_native(constructor_eager({"a": expected}), eager_only=True)["a"]
     )
diff --git a/tests/expr_and_series/tail_test.py b/tests/expr_and_series/tail_test.py
index ac857dee..2202527e 100644
--- a/tests/expr_and_series/tail_test.py
+++ b/tests/expr_and_series/tail_test.py
@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
@@ -14,20 +14,20 @@ def test_tail(
 ) -> None:
     if "polars" in str(constructor_eager) and n < 0:
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(constructor_eager({"a": [1, 2, 3]}))
-    result = df.select(nw.col("a").tail(n))
+    df = nw_v1.from_native(constructor_eager({"a": [1, 2, 3]}))
+    result = df.select(nw_v1.col("a").tail(n))
     expected = {"a": [2, 3]}
     assert_equal_data(result, expected)
 
     with pytest.deprecated_call(
         match="is deprecated and will be removed in a future version"
     ):
-        df.select(nw_main.col("a").tail(5))
+        df.select(nw.col("a").tail(5))
 
 
 @pytest.mark.parametrize("n", [2, -1])
 def test_tail_series(constructor_eager: ConstructorEager, n: int) -> None:
-    df = nw.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
+    df = nw_v1.from_native(constructor_eager({"a": [1, 2, 3]}), eager_only=True)
     result = df.select(df["a"].tail(n))
     expected = {"a": [2, 3]}
     assert_equal_data(result, expected)
diff --git a/tests/frame/gather_every_test.py b/tests/frame/gather_every_test.py
index 6c24713b..4737ed4a 100644
--- a/tests/frame/gather_every_test.py
+++ b/tests/frame/gather_every_test.py
@@ -3,8 +3,8 @@ from __future__ import annotations
 import pandas as pd
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import ConstructorEager
 from tests.utils import assert_equal_data
 
@@ -14,13 +14,13 @@ data = {"a": list(range(10))}
 @pytest.mark.parametrize("n", [1, 2, 3])
 @pytest.mark.parametrize("offset", [1, 2, 3])
 def test_gather_every(constructor_eager: ConstructorEager, n: int, offset: int) -> None:
-    df_v1 = nw.from_native(constructor_eager(data))
+    df_v1 = nw_v1.from_native(constructor_eager(data))
     result = df_v1.gather_every(n=n, offset=offset)
     expected = {"a": data["a"][offset::n]}
     assert_equal_data(result, expected)
 
     # Test deprecation for LazyFrame in main namespace
-    lf = nw_main.from_native(constructor_eager(data)).lazy()
+    lf = nw.from_native(constructor_eager(data)).lazy()
     with pytest.deprecated_call(
         match="is deprecated and will be removed in a future version"
     ):
@@ -33,7 +33,7 @@ def test_gather_every_dask_v1(n: int, offset: int) -> None:
     pytest.importorskip("dask")
     import dask.dataframe as dd
 
-    df_v1 = nw.from_native(dd.from_pandas(pd.DataFrame(data)))
+    df_v1 = nw_v1.from_native(dd.from_pandas(pd.DataFrame(data)))
     result = df_v1.gather_every(n=n, offset=offset)
     expected = {"a": data["a"][offset::n]}
     assert_equal_data(result, expected)
diff --git a/tests/frame/join_test.py b/tests/frame/join_test.py
index 474c8e53..5b686f48 100644
--- a/tests/frame/join_test.py
+++ b/tests/frame/join_test.py
@@ -8,8 +8,8 @@ from typing import Literal
 import pandas as pd
 import pytest
 
-import narwhals as nw_main  # use nw_main in some tests for coverage
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from narwhals.utils import Implementation
 from tests.utils import DUCKDB_VERSION
 from tests.utils import PANDAS_VERSION
@@ -94,8 +94,8 @@ def test_full_join(
     right_on: None | str | list[str],
     constructor: Constructor,
 ) -> None:
-    df_left = nw_main.from_native(constructor(df1))
-    df_right = nw_main.from_native(constructor(df2))
+    df_left = nw.from_native(constructor(df1))
+    df_right = nw.from_native(constructor(df2))
     result = df_left.join(
         df_right, on=on, left_on=left_on, right_on=right_on, how="full"
     ).sort("id", nulls_last=True)
@@ -105,10 +105,10 @@ def test_full_join(
 def test_full_join_duplicate(constructor: Constructor) -> None:
     df1 = {"foo": [1, 2, 3], "val1": [1, 2, 3]}
     df2 = {"foo": [1, 2, 3], "foo_right": [1, 2, 3]}
-    df_left = nw_main.from_native(constructor(df1)).lazy()
-    df_right = nw_main.from_native(constructor(df2)).lazy()
+    df_left = nw.from_native(constructor(df1)).lazy()
+    df_right = nw.from_native(constructor(df2)).lazy()
 
-    exceptions: list[type[Exception]] = [nw.exceptions.NarwhalsError]
+    exceptions: list[type[Exception]] = [nw_v1.exceptions.NarwhalsError]
     if "pyspark" in str(constructor) and "sqlframe" not in str(constructor):
         from pyspark.errors import AnalysisException
 
@@ -128,7 +128,7 @@ def test_inner_join_two_keys(constructor: Constructor) -> None:
         "zor ro": [7.0, 8.0, 9.0],
         "idx": [0, 1, 2],
     }
-    df = nw_main.from_native(constructor(data))
+    df = nw.from_native(constructor(data))
     df_right = df
     result = df.join(
         df_right,
@@ -157,7 +157,7 @@ def test_inner_join_single_key(constructor: Constructor) -> None:
         "zor ro": [7.0, 8.0, 9.0],
         "idx": [0, 1, 2],
     }
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     df_right = df
     result = df.join(
         df_right,  # type: ignore[arg-type]
@@ -184,7 +184,7 @@ def test_cross_join(constructor: Constructor) -> None:
     if "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 1, 4):
         pytest.skip()
     data = {"antananarivo": [1, 3, 2]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     result = df.join(df, how="cross").sort("antananarivo", "antananarivo_right")  # type: ignore[arg-type]
     expected = {
         "antananarivo": [1, 1, 1, 2, 2, 2, 3, 3, 3],
@@ -206,7 +206,7 @@ def test_suffix(constructor: Constructor, how: str, suffix: str) -> None:
         "bob": [4, 4, 6],
         "zor ro": [7.0, 8.0, 9.0],
     }
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     df_right = df
     result = df.join(
         df_right,  # type: ignore[arg-type]
@@ -224,7 +224,7 @@ def test_cross_join_suffix(constructor: Constructor, suffix: str) -> None:
     if "duckdb" in str(constructor) and DUCKDB_VERSION < (1, 1, 4):
         pytest.skip()
     data = {"antananarivo": [1, 3, 2]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     result = df.join(df, how="cross", suffix=suffix).sort(  # type: ignore[arg-type]
         "antananarivo", f"antananarivo{suffix}"
     )
@@ -237,7 +237,7 @@ def test_cross_join_suffix(constructor: Constructor, suffix: str) -> None:
 
 def test_cross_join_non_pandas() -> None:
     data = {"antananarivo": [1, 3, 2]}
-    df = nw.from_native(pd.DataFrame(data))
+    df = nw_v1.from_native(pd.DataFrame(data))
     # HACK to force testing for a non-pandas codepath
     df._compliant_frame._implementation = Implementation.MODIN
     result = df.join(df, how="cross")  # type: ignore[arg-type]
@@ -253,13 +253,17 @@ def test_cross_join_non_pandas() -> None:
     [
         (
             ["antananarivo", "bob"],
-            (nw.col("bob") < 5),
+            (nw_v1.col("bob") < 5),
+            {"antananarivo": [2], "bob": [6], "zor ro": [9]},
+        ),
+        (
+            ["bob"],
+            (nw_v1.col("bob") < 5),
             {"antananarivo": [2], "bob": [6], "zor ro": [9]},
         ),
-        (["bob"], (nw.col("bob") < 5), {"antananarivo": [2], "bob": [6], "zor ro": [9]}),
         (
             ["bob"],
-            (nw.col("bob") > 5),
+            (nw_v1.col("bob") > 5),
             {"antananarivo": [1, 3], "bob": [4, 4], "zor ro": [7.0, 8.0]},
         ),
     ],
@@ -267,11 +271,11 @@ def test_cross_join_non_pandas() -> None:
 def test_anti_join(
     constructor: Constructor,
     join_key: list[str],
-    filter_expr: nw.Expr,
+    filter_expr: nw_v1.Expr,
     expected: dict[str, list[Any]],
 ) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     other = df.filter(filter_expr)
     result = df.join(other, how="anti", left_on=join_key, right_on=join_key)  # type: ignore[arg-type]
     assert_equal_data(result, expected)
@@ -282,22 +286,22 @@ def test_anti_join(
     [
         (
             "antananarivo",
-            (nw.col("bob") > 5),
+            (nw_v1.col("bob") > 5),
             {"antananarivo": [2], "bob": [6], "zor ro": [9]},
         ),
         (
             ["antananarivo"],
-            (nw.col("bob") > 5),
+            (nw_v1.col("bob") > 5),
             {"antananarivo": [2], "bob": [6], "zor ro": [9]},
         ),
         (
             ["bob"],
-            (nw.col("bob") < 5),
+            (nw_v1.col("bob") < 5),
             {"antananarivo": [1, 3], "bob": [4, 4], "zor ro": [7, 8]},
         ),
         (
             ["antananarivo", "bob"],
-            (nw.col("bob") < 5),
+            (nw_v1.col("bob") < 5),
             {"antananarivo": [1, 3], "bob": [4, 4], "zor ro": [7, 8]},
         ),
     ],
@@ -305,11 +309,11 @@ def test_anti_join(
 def test_semi_join(
     constructor: Constructor,
     join_key: list[str],
-    filter_expr: nw.Expr,
+    filter_expr: nw_v1.Expr,
     expected: dict[str, list[Any]],
 ) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     other = df.filter(filter_expr)
     result = df.join(other, how="semi", left_on=join_key, right_on=join_key).sort(  # type: ignore[arg-type]
         "antananarivo"
@@ -320,7 +324,7 @@ def test_semi_join(
 @pytest.mark.parametrize("how", ["right"])
 def test_join_not_implemented(constructor: Constructor, how: str) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
 
     with pytest.raises(
         NotImplementedError,
@@ -342,8 +346,8 @@ def test_left_join(constructor: Constructor) -> None:
         "co": [4.0, 5.0, 7.0],
         "idx": [0.0, 1.0, 2.0],
     }
-    df_left = nw.from_native(constructor(data_left))
-    df_right = nw.from_native(constructor(data_right))
+    df_left = nw_v1.from_native(constructor(data_left))
+    df_right = nw_v1.from_native(constructor(data_right))
     result = df_left.join(df_right, left_on="bob", right_on="co", how="left")  # type: ignore[arg-type]
     result = result.sort("idx")
     result = result.drop("idx_right")
@@ -372,8 +376,8 @@ def test_left_join(constructor: Constructor) -> None:
 def test_left_join_multiple_column(constructor: Constructor) -> None:
     data_left = {"antananarivo": [1, 2, 3], "bob": [4, 5, 6], "idx": [0, 1, 2]}
     data_right = {"antananarivo": [1, 2, 3], "c": [4, 5, 6], "idx": [0, 1, 2]}
-    df_left = nw.from_native(constructor(data_left))
-    df_right = nw.from_native(constructor(data_right))
+    df_left = nw_v1.from_native(constructor(data_left))
+    df_right = nw_v1.from_native(constructor(data_right))
     result = df_left.join(
         df_right,  # type: ignore[arg-type]
         left_on=["antananarivo", "bob"],
@@ -399,8 +403,8 @@ def test_left_join_overlapping_column(constructor: Constructor) -> None:
         "d": [1.0, 4.0, 2.0],
         "idx": [0.0, 1.0, 2.0],
     }
-    df_left = nw.from_native(constructor(data_left))
-    df_right = nw.from_native(constructor(data_right))
+    df_left = nw_v1.from_native(constructor(data_left))
+    df_right = nw_v1.from_native(constructor(data_right))
     result = df_left.join(df_right, left_on="bob", right_on="c", how="left").sort("idx")  # type: ignore[arg-type]
     result = result.drop("idx_right")
     expected: dict[str, list[Any]] = {
@@ -434,7 +438,7 @@ def test_left_join_overlapping_column(constructor: Constructor) -> None:
 @pytest.mark.parametrize("how", ["inner", "left", "semi", "anti"])
 def test_join_keys_exceptions(constructor: Constructor, how: str) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
 
     with pytest.raises(
         ValueError,
@@ -501,10 +505,10 @@ def test_joinasof_numeric(
         ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor))
     ):
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor({"antananarivo": [1, 5, 10], "val": ["a", "b", "c"]})
     ).sort("antananarivo")
-    df_right = nw.from_native(
+    df_right = nw_v1.from_native(
         constructor({"antananarivo": [1, 2, 3, 6, 7], "val": [1, 2, 3, 6, 7]})
     ).sort("antananarivo")
     result = df.join_asof(
@@ -571,7 +575,7 @@ def test_joinasof_time(
         request.applymarker(pytest.mark.xfail)
     if PANDAS_VERSION < (2, 1) and ("pandas_pyarrow" in str(constructor)):
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor(
             {
                 "datetime": [
@@ -583,7 +587,7 @@ def test_joinasof_time(
             }
         )
     ).sort("datetime")
-    df_right = nw.from_native(
+    df_right = nw_v1.from_native(
         constructor(
             {
                 "datetime": [
@@ -618,7 +622,7 @@ def test_joinasof_by(
         ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor))
     ):
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor(
             {
                 "antananarivo": [1, 5, 7, 10],
@@ -627,7 +631,7 @@ def test_joinasof_by(
             }
         )
     ).sort("antananarivo")
-    df_right = nw.from_native(
+    df_right = nw_v1.from_native(
         constructor(
             {"antananarivo": [1, 4, 5, 8], "bob": ["D", "D", "A", "F"], "d": [1, 3, 4, 1]}
         )
@@ -654,10 +658,10 @@ def test_joinasof_suffix(
         ("pandas_pyarrow" in str(constructor)) or ("pandas_nullable" in str(constructor))
     ):
         request.applymarker(pytest.mark.xfail)
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor({"antananarivo": [1, 5, 10], "val": ["a", "b", "c"]})
     ).sort("antananarivo")
-    df_right = nw.from_native(
+    df_right = nw_v1.from_native(
         constructor({"antananarivo": [1, 2, 3, 6, 7], "val": [1, 2, 3, 6, 7]})
     ).sort("antananarivo")
     result = df.join_asof(
@@ -679,7 +683,7 @@ def test_joinasof_not_implemented(
     constructor: Constructor, strategy: Literal["backward", "forward"]
 ) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
 
     with pytest.raises(
         NotImplementedError,
@@ -695,7 +699,7 @@ def test_joinasof_not_implemented(
 
 def test_joinasof_keys_exceptions(constructor: Constructor) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
 
     with pytest.raises(
         ValueError,
@@ -736,7 +740,7 @@ def test_joinasof_keys_exceptions(constructor: Constructor) -> None:
 
 def test_joinasof_by_exceptions(constructor: Constructor) -> None:
     data = {"antananarivo": [1, 3, 2], "bob": [4, 4, 6], "zor ro": [7.0, 8.0, 9.0]}
-    df = nw.from_native(constructor(data))
+    df = nw_v1.from_native(constructor(data))
     with pytest.raises(
         ValueError,
         match="If `by` is specified, `by_left` and `by_right` should be None.",
@@ -790,8 +794,8 @@ def test_join_duplicate_column_names(
     elif "modin" in str(constructor):
         exception = NotImplementedError
     else:
-        exception = nw.exceptions.DuplicateError
+        exception = nw_v1.exceptions.DuplicateError
     df = constructor({"a": [1, 2, 3, 4, 5], "b": [6, 6, 6, 6, 6]})
-    dfn = nw.from_native(df)
+    dfn = nw_v1.from_native(df)
     with pytest.raises(exception):
         dfn.join(dfn, on=["a"]).join(dfn, on=["a"]).lazy().collect()  # type: ignore[arg-type]
diff --git a/tests/frame/schema_test.py b/tests/frame/schema_test.py
index e7f2b562..f4cb9b93 100644
--- a/tests/frame/schema_test.py
+++ b/tests/frame/schema_test.py
@@ -11,8 +11,8 @@ from typing import Any
 import pandas as pd
 import pytest
 
-import narwhals as nw_main
-import narwhals.stable.v1 as nw
+import narwhals as nw
+import narwhals.stable.v1 as nw_v1
 from tests.utils import PANDAS_VERSION
 
 if TYPE_CHECKING:
@@ -31,11 +31,11 @@ data = {
 
 @pytest.mark.filterwarnings("ignore:Determining|Resolving.*")
 def test_schema(constructor: Constructor) -> None:
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor({"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]})
     )
     result = df.schema
-    expected = {"a": nw.Int64, "b": nw.Int64, "z": nw.Float64}
+    expected = {"a": nw_v1.Int64, "b": nw_v1.Int64, "z": nw_v1.Float64}
 
     result = df.schema
     assert result == expected
@@ -44,10 +44,10 @@ def test_schema(constructor: Constructor) -> None:
 
 
 def test_collect_schema(constructor: Constructor) -> None:
-    df = nw.from_native(
+    df = nw_v1.from_native(
         constructor({"a": [1, 3, 2], "b": [4, 4, 6], "z": [7.1, 8.0, 9.0]})
     )
-    expected = {"a": nw.Int64, "b": nw.Int64, "z": nw.Float64}
+    expected = {"a": nw_v1.Int64, "b": nw_v1.Int64, "z": nw_v1.Float64}
 
     result = df.collect_schema()
     assert result == expected
@@ -56,22 +56,22 @@ def test_collect_schema(constructor: Constructor) -> None:
 
 
 def test_schema_comparison() -> None:
-    assert {"a": nw.String()} != {"a": nw.Int32()}
-    assert {"a": nw.Int32()} == {"a": nw.Int32()}
+    assert {"a": nw_v1.String()} != {"a": nw_v1.Int32()}
+    assert {"a": nw_v1.Int32()} == {"a": nw_v1.Int32()}
 
 
 def test_object() -> None:
     class Foo: ...
 
     df = pd.DataFrame({"a": [Foo()]}).astype(object)
-    result = nw.from_native(df).schema
-    assert result["a"] == nw.Object
+    result = nw_v1.from_native(df).schema
+    assert result["a"] == nw_v1.Object
 
 
 def test_string_disguised_as_object() -> None:
     df = pd.DataFrame({"a": ["foo", "bar"]}).astype(object)
-    result = nw.from_native(df).schema
-    assert result["a"] == nw.String
+    result = nw_v1.from_native(df).schema
+    assert result["a"] == nw_v1.String
 
 
 def test_actual_object(
@@ -83,9 +83,9 @@ def test_actual_object(
     class Foo: ...
 
     data = {"a": [Foo()]}
-    df = nw.from_native(constructor_eager(data))
+    df = nw_v1.from_native(constructor_eager(data))
     result = df.schema
-    assert result == {"a": nw.Object}
+    assert result == {"a": nw_v1.Object}
 
 
 @pytest.mark.skipif(PANDAS_VERSION < (2, 0, 0), reason="too old")
@@ -139,28 +139,28 @@ def test_dtypes() -> None:
             "u": pl.Struct({"a": pl.Int64}),
         },
     )
-    df_from_pl = nw.from_native(df_pl, eager_only=True)
+    df_from_pl = nw_v1.from_native(df_pl, eager_only=True)
     expected = {
-        "a": nw.Int64,
-        "b": nw.Int32,
-        "c": nw.Int16,
-        "d": nw.Int8,
-        "e": nw.UInt64,
-        "f": nw.UInt32,
-        "g": nw.UInt16,
-        "h": nw.UInt8,
-        "i": nw.Float64,
-        "j": nw.Float32,
-        "k": nw.String,
-        "l": nw.Datetime,
-        "m": nw.Boolean,
-        "n": nw.Date,
-        "o": nw.Datetime,
-        "p": nw.Categorical,
-        "q": nw.Duration,
-        "r": nw.Enum,
-        "s": nw.List,
-        "u": nw.Struct,
+        "a": nw_v1.Int64,
+        "b": nw_v1.Int32,
+        "c": nw_v1.Int16,
+        "d": nw_v1.Int8,
+        "e": nw_v1.UInt64,
+        "f": nw_v1.UInt32,
+        "g": nw_v1.UInt16,
+        "h": nw_v1.UInt8,
+        "i": nw_v1.Float64,
+        "j": nw_v1.Float32,
+        "k": nw_v1.String,
+        "l": nw_v1.Datetime,
+        "m": nw_v1.Boolean,
+        "n": nw_v1.Date,
+        "o": nw_v1.Datetime,
+        "p": nw_v1.Categorical,
+        "q": nw_v1.Duration,
+        "r": nw_v1.Enum,
+        "s": nw_v1.List,
+        "u": nw_v1.Struct,
     }
 
     assert df_from_pl.schema == df_from_pl.collect_schema()
@@ -168,16 +168,16 @@ def test_dtypes() -> None:
     assert {name: df_from_pl[name].dtype for name in df_from_pl.columns} == expected
 
     # pandas/pyarrow only have categorical, not enum
-    expected["r"] = nw.Categorical
+    expected["r"] = nw_v1.Categorical
 
-    df_from_pd = nw.from_native(
+    df_from_pd = nw_v1.from_native(
         df_pl.to_pandas(use_pyarrow_extension_array=True), eager_only=True
     )
 
     assert df_from_pd.schema == df_from_pd.collect_schema() == expected
     assert {name: df_from_pd[name].dtype for name in df_from_pd.columns} == expected
 
-    df_from_pa = nw.from_native(df_pl.to_arrow(), eager_only=True)
+    df_from_pa = nw_v1.from_native(df_pl.to_arrow(), eager_only=True)
 
     assert df_from_pa.schema == df_from_pa.collect_schema() == expected
     assert {name: df_from_pa[name].dtype for name in df_from_pa.columns} == expected
@@ -185,24 +185,24 @@ def test_dtypes() -> None:
 
 def test_unknown_dtype() -> None:
     df = pd.DataFrame({"a": pd.period_range("2000", periods=3, freq="M")})
-    assert nw.from_native(df).schema == {"a": nw.Unknown}
+    assert nw_v1.from_native(df).schema == {"a": nw_v1.Unknown}
 
 
 def test_hash() -> None:
-    assert nw.Int64() in {nw.Int64, nw.Int32}
+    assert nw_v1.Int64() in {nw_v1.Int64, nw_v1.Int32}
 
 
 @pytest.mark.parametrize(
     ("method", "expected"),
     [
         ("names", ["a", "b", "c"]),
-        ("dtypes", [nw.Int64(), nw.Float32(), nw.String()]),
+        ("dtypes", [nw_v1.Int64(), nw_v1.Float32(), nw_v1.String()]),
         ("len", 3),
     ],
 )
 def test_schema_object(method: str, expected: Any) -> None:
-    data = {"a": nw.Int64(), "b": nw.Float32(), "c": nw.String()}
-    schema = nw.Schema(data)
+    data = {"a": nw_v1.Int64(), "b": nw_v1.Float32(), "c": nw_v1.String()}
+    schema = nw_v1.Schema(data)
     assert getattr(schema, method)() == expected
 
 
@@ -211,7 +211,7 @@ def test_validate_not_duplicated_columns_pandas_like() -> None:
     with pytest.raises(
         ValueError, match="Expected unique column names, got:\n- 'a' 2 times"
     ):
-        nw.from_native(df, eager_only=True)
+        nw_v1.from_native(df, eager_only=True)
 
 
 def test_validate_not_duplicated_columns_arrow() -> None:
@@ -222,7 +222,7 @@ def test_validate_not_duplicated_columns_arrow() -> None:
     with pytest.raises(
         ValueError, match="Expected unique column names, got:\n- 'a' 2 times"
     ):
-        nw.from_native(table, eager_only=True)
+        nw_v1.from_native(table, eager_only=True)
 
 
 def test_validate_not_duplicated_columns_duckdb() -> None:
@@ -233,7 +233,7 @@ def test_validate_not_duplicated_columns_duckdb() -> None:
     with pytest.raises(
         ValueError, match="Expected unique column names, got:\n- 'a' 2 times"
     ):
-        nw.from_native(rel, eager_only=False).lazy().collect()
+        nw_v1.from_native(rel, eager_only=False).lazy().collect()
 
 
 @pytest.mark.skipif(
@@ -251,39 +251,39 @@ def test_nested_dtypes() -> None:
         {"a": [[1, 2]], "b": [[1, 2]], "c": [{"a": 1}]},
         schema_overrides={"b": pl.Array(pl.Int64, 2)},
     ).to_pandas(use_pyarrow_extension_array=True)
-    nwdf: nw.DataFrame[Any] | nw.LazyFrame[Any] = nw.from_native(df_pd)
+    nwdf: nw_v1.DataFrame[Any] | nw_v1.LazyFrame[Any] = nw_v1.from_native(df_pd)
     assert nwdf.schema == {
-        "a": nw.List(nw.Int64),
-        "b": nw.Array(nw.Int64, 2),
-        "c": nw.Struct({"a": nw.Int64}),
+        "a": nw_v1.List(nw_v1.Int64),
+        "b": nw_v1.Array(nw_v1.Int64, 2),
+        "c": nw_v1.Struct({"a": nw_v1.Int64}),
     }
     df_pl = pl.DataFrame(
         {"a": [[1, 2]], "b": [[1, 2]], "c": [{"a": 1}]},
         schema_overrides={"b": pl.Array(pl.Int64, 2)},
     )
-    nwdf = nw.from_native(df_pl)
+    nwdf = nw_v1.from_native(df_pl)
     assert nwdf.schema == {
-        "a": nw.List(nw.Int64),
-        "b": nw.Array(nw.Int64, 2),
-        "c": nw.Struct({"a": nw.Int64}),
+        "a": nw_v1.List(nw_v1.Int64),
+        "b": nw_v1.Array(nw_v1.Int64, 2),
+        "c": nw_v1.Struct({"a": nw_v1.Int64}),
     }
 
     df_pa = pl.DataFrame(
         {"a": [[1, 2]], "b": [[1, 2]], "c": [{"a": 1, "b": "x", "c": 1.1}]},
         schema_overrides={"b": pl.Array(pl.Int64, 2)},
     ).to_arrow()
-    nwdf = nw.from_native(df_pa)
+    nwdf = nw_v1.from_native(df_pa)
     assert nwdf.schema == {
-        "a": nw.List(nw.Int64),
-        "b": nw.Array(nw.Int64, 2),
-        "c": nw.Struct({"a": nw.Int64, "b": nw.String, "c": nw.Float64}),
+        "a": nw_v1.List(nw_v1.Int64),
+        "b": nw_v1.Array(nw_v1.Int64, 2),
+        "c": nw_v1.Struct({"a": nw_v1.Int64, "b": nw_v1.String, "c": nw_v1.Float64}),
     }
     rel = duckdb.sql("select * from df_pa")
-    nwdf = nw.from_native(rel)
+    nwdf = nw_v1.from_native(rel)
     assert nwdf.schema == {
-        "a": nw.List(nw.Int64),
-        "b": nw.Array(nw.Int64, 2),
-        "c": nw.Struct({"a": nw.Int64, "b": nw.String, "c": nw.Float64}),
+        "a": nw_v1.List(nw_v1.Int64),
+        "b": nw_v1.Array(nw_v1.Int64, 2),
+        "c": nw_v1.Struct({"a": nw_v1.Int64, "b": nw_v1.String, "c": nw_v1.Float64}),
     }
 
 
@@ -301,8 +301,11 @@ def test_nested_dtypes_ibis(request: pytest.FixtureRequest) -> None:  # pragma:
         schema_overrides={"b": pl.Array(pl.Int64, 2)},
     )
     tbl = ibis.memtable(df[["a", "c"]])
-    nwdf = nw.from_native(tbl)
-    assert nwdf.schema == {"a": nw.List(nw.Int64), "c": nw.Struct({"a": nw.Int64})}
+    nwdf = nw_v1.from_native(tbl)
+    assert nwdf.schema == {
+        "a": nw_v1.List(nw_v1.Int64),
+        "c": nw_v1.Struct({"a": nw_v1.Int64}),
+    }
 
 
 @pytest.mark.skipif(
@@ -322,22 +325,22 @@ def test_nested_dtypes_dask() -> None:
             schema_overrides={"b": pl.Array(pl.Int64, 2)},
         ).to_pandas(use_pyarrow_extension_array=True)
     )
-    nwdf = nw.from_native(df)
+    nwdf = nw_v1.from_native(df)
     assert nwdf.schema == {
-        "a": nw.List(nw.Int64),
-        "b": nw.Array(nw.Int64, 2),
-        "c": nw.Struct({"a": nw.Int64}),
+        "a": nw_v1.List(nw_v1.Int64),
+        "b": nw_v1.Array(nw_v1.Int64, 2),
+        "c": nw_v1.Struct({"a": nw_v1.Int64}),
     }
 
 
 def test_all_nulls_pandas() -> None:
     assert (
-        nw_main.from_native(pd.Series([None] * 3, dtype="object"), series_only=True).dtype
-        == nw_main.String
+        nw.from_native(pd.Series([None] * 3, dtype="object"), series_only=True).dtype
+        == nw.String
     )
     assert (
-        nw.from_native(pd.Series([None] * 3, dtype="object"), series_only=True).dtype
-        == nw.Object
+        nw_v1.from_native(pd.Series([None] * 3, dtype="object"), series_only=True).dtype
+        == nw_v1.Object
     )
 
 
@@ -389,26 +392,26 @@ def test_all_nulls_pandas() -> None:
 def test_schema_to_pandas(
     dtype_backend: DTypeBackend | Sequence[DTypeBackend] | None, expected: dict[str, Any]
 ) -> None:
-    schema = nw.Schema(
+    schema = nw_v1.Schema(
         {
-            "a": nw.Int64(),
-            "b": nw.String(),
-            "c": nw.Boolean(),
-            "d": nw.Float64(),
-            "e": nw.Datetime("ns"),
+            "a": nw_v1.Int64(),
+            "b": nw_v1.String(),
+            "c": nw_v1.Boolean(),
+            "d": nw_v1.Float64(),
+            "e": nw_v1.Datetime("ns"),
         }
     )
     assert schema.to_pandas(dtype_backend) == expected
 
 
 def test_schema_to_pandas_strict_zip() -> None:
-    schema = nw.Schema(
+    schema = nw_v1.Schema(
         {
-            "a": nw.Int64(),
-            "b": nw.String(),
-            "c": nw.Boolean(),
-            "d": nw.Float64(),
-            "e": nw.Datetime("ns"),
+            "a": nw_v1.Int64(),
+            "b": nw_v1.String(),
+            "c": nw_v1.Boolean(),
+            "d": nw_v1.Float64(),
+            "e": nw_v1.Datetime("ns"),
         }
     )
     dtype_backend: list[DTypeBackend] = ["numpy_nullable", "pyarrow", None]
@@ -431,7 +434,7 @@ def test_schema_to_pandas_strict_zip() -> None:
 
 
 def test_schema_to_pandas_invalid() -> None:
-    schema = nw.Schema({"a": nw.Int64()})
+    schema = nw_v1.Schema({"a": nw_v1.Int64()})
     msg = "Expected one of {None, 'pyarrow', 'numpy_nullable'}, got: 'cabbage'"
     with pytest.raises(ValueError, match=msg):
         schema.to_pandas("cabbage")  # type: ignore[arg-type]