Lpjݔ2SSKJr SSKrSSKJrJrJrJrJr SSK J r SSK J r J r JrJrJrJrJr SSKJrJr SSKJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$ SSK%J&r&J'r'J(r( SS K)J*r*J+r+ SS K,J-r-J.r. SS K/J0r0 SS K1J2r2 SS K3J4r4 SSK5J6r6 SSK7J8r8 SSK9J:r: SSK;Jr> SSK?J@r@ \ (aZSSKAJBrB SSK JCrC SSKDrESSKFrGSSKHrISSKJJKrK SSKLJMrM SSKNJOrOJPrPJQrQJRrR SSKSJTrTJUrU SSK)JVrV SSK?JWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrb "SS\\@5rcg)) annotationsN)CallableIterableIteratorMappingSequence)partial) TYPE_CHECKINGAnyClassVarGenericLiteralcastoverload)ExprKindExprNode) NO_DEFAULTImplementationVersion_Implementation_resolve_sample_size_validate_rolling_arguments ensure_type generate_repris_compliant_seriesis_eager_allowedis_index_selectorqualified_type_namesupports_arrow_c_streamunstable)is_numpy_arrayis_numpy_array_1dis_numpy_scalar)_validate_dtype_validate_into_dtype) ComputeErrorInvalidOperationError)Expr)colSeriesCatNamespaceSeriesDateTimeNamespaceSeriesListNamespaceSeriesStringNamespaceSeriesStructNamespace) to_native) IntoSeriesT) ModuleType)NoReturn)Self)CompliantSeries) EagerAllowed IntoBackend NoDefault PluginName) DataFrameMultiIndexSelector)DType) ClosedIntervalFillNullStrategy IntoDTypeModeKeepStrategyNonNestedLiteralNumericLiteral PythonLiteral RankMethodRollingInterpolationMethodSingleIndexSelectorTemporalLiteral_1DArrayc \rSrSr%Sr\R rS\S'\ SSj5r \ SSj5r SSjr SSjr \SSS jj5r\SSS jj5r\"5rS \S 'SSjrSSSjjr\SSj5r\SSj5rSSjrSSjrSSSjjrSSjrSSjr\ SSj5rSSjrSSjrSSjrSSjrSSjr SSjr!\ SSj5r"\ SSj5r#S S S S S S!S"S#.SS$jjr$SS%jr%SS&jr&SS'jr'SS(jr(SS)jr)SS*jr*SS+jr+SS,jr,SS-jr-SS.jr.SS/jr/SS0jr0SS1jr1SS2jr2SS3jr3S!S4.SS5jjr4S!S4.SS6jjr5SSS7jjr6SS8jr7SS9jr8SS:jr9SS;jr:SS<jr;SS=jr.SS?jjr=S"S@.SSAjjr>SSBjr?SSCjr@SS S"S SD.SSEjjjrASSFjrBSSGjrCS\DS SH.SSIjjjrES"S"SJ.SSKjjrFSSLjrGSSMjrHSSSNjjrISSOjrJSSSPjjrKSSQjrLSSRjrMSSSjrNSSTjrOSSUjrPSSVjrQSSWjrRSSXjrSSSYjrTSSZjrUSS[jrVSS\jrWSS]jrXSS^jrYSS_jrZSS`jr[SSajr\SSbjr]SScjr^SSdjr_SSejr`SSfjraSSgjrbSShjrcSSijrdSSjjreSSkjrfSSljrgSSmjrhSSnjriSSojrjSSpjrkSSqjrlSSrjrmSSsjrnSStjroSSujrpS"Sv.SSwjjrqS"S"S S"Sx.SSyjjrrSSzjrsSS{jrtSSS|jjruSSS}jjrvSSS~jjrwSSSjjrxSSjrySSjrzSS"S.SSjjr{SSSjjr|SSjr}\SS.SSjj5r~\SSj5r~SS.SSjjr~SSjrS"S>.SSjjrS"S>.SSjjrS"S>.SSjjrS"S>.SSjjrS S"S.SSjjrS S"S.SSjjrS S"S!S.SSjjrS S"S!S.SSjjrSSjrSSjrSS"Sv.SSjjjrSS S S.SSjjjr\GR4SSjjrSSjrSSjrSSjrSSjrSSS"S.SSjjr\S"S.SSjj5r\ SSj5r\ SSj5r\ SSj5r\ SSj5r\ SSj5rSrg (SeriesCaNarwhals Series, backed by a native series. Warning: This class is not meant to be instantiated directly - instead: - If the native object is a series from one of the supported backend (e.g. pandas.Series, polars.Series, pyarrow.ChunkedArray), you can use [`narwhals.from_native`][]: ```py narwhals.from_native(native_series, allow_series=True) narwhals.from_native(native_series, series_only=True) ``` - If the object is a generic sequence (e.g. a list or a tuple of values), you can create a series via [`narwhals.new_series`][], e.g.: ```py narwhals.new_series(name="price", values=[10.5, 9.4, 1.2], backend="pandas") ``` zClassVar[Version]_versioncUR$N)_compliant_seriesselfs K/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/series.py _compliantSeries._compliantZs%%%cSSKJn U$)Nr)r>)narwhals.dataframer>)rUr>s rV _dataframeSeries._dataframe^s 0rYcZ[[[RSURS95$)Nz_expr._from_series)series)r(rrSERIESrWrTs rV_to_exprSeries._to_exprds$ X__&:4?? S  rYcX l[U5(aUR5UlgS[ U5S3n[ U5e)NzQExpected Polars Series or an object which implements `__narwhals_series__`, got: .)_levelr__narwhals_series__rStypeAssertionError)rUr_levelmsgs rV__init__Series.__init__isN?D v & &**,  "ffjkqfresstuC % %rYNc[U5(d Sn[U5eU(a [U5 [R"U5n[ U5(asUR RR U5RnURU5RU5nU(aU"URU5SS9$U"USS9$USUS3n[U5e)uConstruct a Series from a NumPy ndarray. Arguments: name: Name of resulting Series. values: One-dimensional data represented as a NumPy ndarray. dtype: (Narwhals) dtype. If not provided, the native library may auto-infer it from `values`. backend: specifies which eager backend instantiate to. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. Examples: >>> import numpy as np >>> import polars as pl >>> import narwhals as nw >>> >>> arr = np.arange(5, 10) >>> nw.Series.from_numpy("arr", arr, dtype=nw.Int8, backend="polars") ┌──────────────────┐ | Narwhals Series | |------------------| |shape: (5,) | |Series: 'arr' [i8]| |[ | | 5 | | 6 | | 7 | | 8 | | 9 | |] | └──────────────────┘ z)`from_numpy` only accepts 1D numpy arraysfullriz support in Narwhals is lazy-only, but `Series.from_numpy` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.Series.from_numpy(arr, backend='pyarrow').to_frame().lazy('')) r" ValueErrorr%r from_backendrrP namespace compliant from_numpyaliasr clsnamevaluesdtypebackendrjimplementationnsrts rVruSeries.from_numpyus\!((=CS/ !   ''44W= N + +''44^DNNB f-33D9I9>>%0??y/ /QQ_P``b d orYc[U5(aURXX4S9$U(a [U5 [U[5(dS[ U5<S3n[ U5e[R"U5n[U5(aPURRRU5RnURRX'XS9nU"USS9$USUS3n[U5e) uConstruct a Series from an iterable. Arguments: name: Name of resulting Series. values: One-dimensional data represented as an iterable. dtype: (Narwhals) dtype. If not provided, the native library may auto-infer it from `values`. backend: specifies which eager backend instantiate to. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> values = [4, 1, 3, 2] >>> nw.Series.from_iterable("a", values, dtype=nw.UInt32, backend="pandas") ┌──────────────────────┐ | Narwhals Series | |----------------------| |0 4 | |1 1 | |2 3 | |3 2 | |Name: a, dtype: uint32| └──────────────────────┘ )r|z(Expected values to be an iterable, got: rd)contextryr{rnroz support in Narwhals is lazy-only, but `Series.from_iterable` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.Series.from_iterable('a', [1,2,3], backend='pyarrow').to_frame().lazy('rp)r!rur% isinstancerr TypeErrorrrrrrPrsrt_series from_iterablerqrws rVrSeries.from_iterablesR & ! !>>$>G G   '&(++<=PQW=X<[[\]CC. '44W= N + +''44^DNNB 001Iy/ /]]k\lln p orYrr}cSn[U5e)Nathe truth value of a Series is ambiguous Here are some things you might want to try: - instead of `if s`, use `if not s.is_empty()` - instead of `s1 and s2`, use `s1 & s2` - instead of `s1 or s2`, use `s1 | s2` - instead of `s in [y, z]`, use `s.is_in([y, z])` )r)rUrjs rV__bool__Series.__bool__ s B nrYc4URRXS9$)N)r{copy)rS __array__)rUr{rs rVrSeries.__array__s%%//e/GGrYcgrRrUidxs rV __getitem__Series.__getitem__>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True)[0] 1 >>> nw.from_native(s_native, series_only=True)[ ... :2 ... ].to_native() # doctest:+ELLIPSIS [ [ 1, 2 ] ] >iuz*Unexpected type for `Series.__getitem__`: z. Hints: - use `s.item` to select a single item. - Use `s[indices]` to select rows positionally. - Use `s.filter(mask)` to filter rows based on a boolean mask.)rintr#r{kindrSitemr4 __class___with_compliant _with_nativerrgrrN)rUrrjs rVrrs%@ c3   C SYY^^z%A",S#"6"6#c(CC))..s3 3 c>>+55 6 6&&t'='='J'J3'OPC %%(>s?T?T(UV Vc3''''##D$:$:3$?@@rYc6URR5$rR)rS__native_namespace__rTs rVrSeries.__native_namespace__Us%%::<=16.0.0' is required for `Series.__arrow_c_stream__` for object of type N)rr) chunked_array) rSnativer__arrow_c_stream__rPYARROW_backend_versionModuleNotFoundErrorrgnarwhals._arrow.utilsrto_arrow)rUr native_series pa_versionexcrjrcas rVrSeries.__arrow_c_stream__Xs..55 "= 1 1 33EU3V V 4'//@@BJ  efjkxfyez{C%c* *7 4==? +$$6F$GG# 4efjkxfyez{C%c* 3 4sB C)CCc.URR$)aLConvert Narwhals series to native series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2]) >>> s = nw.from_native(s_native, series_only=True) >>> s.to_native() # doctest: +NORMALIZE_WHITESPACE shape: (2,) Series: '' [i64] [ 1 2 ] )rSrrTs rVr4Series.to_nativess"%%,,,rYc8[[U5RSURS9n[ U[ 5(d>[ U[ 5(dU/nURRnU"XRS9nUR5(aU$[ U[ 5(d3[ U[ 5(a[ U[5(aU/nU"US9nURRURUR5nURU5$)a Set value(s) at the given index location(s). Arguments: indices: Integer(s) representing the index location(s). values: Replacement values. Note: This method always returns a new Series, without modifying the original one. Using this function in a for-loop is an anti-pattern, we recommend building up your positions and values beforehand and doing an update in one go. For example, instead of ```python for i in [1, 3, 2]: value = some_function(i) s = s.scatter(i, value) ``` prefer ```python positions = [1, 3, 2] values = [some_function(x) for x in positions] s = s.scatter(positions, values) ``` Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df_nw = nw.from_native(df_native) >>> df_nw.with_columns(df_nw["a"].scatter([0, 1], [999, 888])).to_native() pyarrow.Table a: int64 b: int64 ---- a: [[999,888,3]] b: [[4,5,6]] )ryr|)rzr{)rz)r rgrr}rrNrrPdtypesInt64is_emptystrrWscatterr)rUindicesrz into_seriesrresults rVrSeries.scatters\ J $ $2t7J7J '6**gx00")]]))F! EG     K&&))fh//:fc3J3J  /F((););V=N=NO##F++rYc8URR54$)zGet the shape of the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).shape (3,) )rSlenrTs rVshape Series.shapes&&**,..rYcH[U[5(a UR$U$rR)rrNrS)rUargs rV_extract_nativeSeries._extract_natives c6 " "(( ( rYc4URXRS9$)Nro)rre)rUr_s rVrSeries._with_compliants~~fKK~88rYcU"U/UQ70UD6$)aUPipe function call. Examples: >>> import polars as pl >>> import narwhals as nw >>> s_native = pl.Series([1, 2, 3]) >>> s = nw.from_native(s_native, series_only=True) >>> s.pipe(lambda x: x + 2).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 3 4 5 ] r)rUfunctionargskwargss rVpipe Series.pipes".t.v..rYcR[SUR5R55$)NzNarwhals Series)rr4__repr__rTs rVrSeries.__repr__s .0@0I0I0KLLrYc,[UR5$rRrrSrTs rV__len__Series.__len__s4))**rYc,[UR5$)aReturn the number of elements in the Series. Null values count towards the total. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native(s_native, series_only=True).len() 3 rrTs rVr Series.lens4))**rYc.URR$)zGet the data type of the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).dtype Int64 )rSr{rTs rVr{ Series.dtypes%%+++rYc.URR$)zGet the name of the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("foo", [1, 2, 3]) >>> nw.from_native(s_native, series_only=True).name 'foo' )rSryrTs rVry Series.names%%***rYTFcomspan half_lifealphaadjust min_samples ignore_nullsc ^URURRUUUUUUUS95$)a[Compute exponentially-weighted moving average. Arguments: com: Specify decay in terms of center of mass, $\gamma$, with
$\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$ span: Specify decay in terms of span, $\theta$, with
$\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$ half_life: Specify decay in terms of half-life, $\tau$, with
$\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`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series(name="a", data=[1, 2, 3]) >>> nw.from_native(s_native, series_only=True).ewm_mean( ... com=1, ignore_nulls=False ... ).to_native() 0 1.000000 1 1.666667 2 2.428571 Name: a, dtype: float64 r)rrSewm_mean)rUrrrrrrrs rVrSeries.ewm_mean#sFt##  " " + +#') ,   rYcl[U5 URURRU55$)aCast between data types. Arguments: dtype: Data type that the object will be cast into. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[True, False, True]]) >>> nw.from_native(s_native, series_only=True).cast(nw.Int64).to_native() [ [ 1, 0, 1 ] ] )r$rrSr)rUr{s rVr Series.castis.* ##D$:$:$?$?$FGGrYcfURURR5URS9$)uConvert to dataframe. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("a", [1, 2]) >>> nw.from_native(s_native, series_only=True).to_frame().to_native() shape: (2, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ └─────┘ ro)r\rSto_framererTs rVrSeries.to_frames*&t55>>@ TTrYc6URR5$)aConvert to list. Notes: This function converts to Python scalars. It's typically more efficient to keep your data in the format native to your original dataframe, so we recommend only calling this when you absolutely need to. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).to_list() [1, 2, 3] )rSto_listrTs rVrSeries.to_lists"%%--//rYc6URR5$)zReduce this Series to the mean value. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.2, 4.2]) >>> nw.from_native(s_native, series_only=True).mean() np.float64(2.7) )rSmeanrTs rVr Series.means%%**,,rYc6URR5$)aqReduce this Series to the median value. Notes: Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[5, 3, 8]]) >>> nw.from_native(s_native, series_only=True).median() 5.0 )rSmedianrTs rVr Series.medians%%,,..rYc6URR5$)aCalculate the sample skewness of the Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 1, 2, 10, 100]) >>> nw.from_native(s_native, series_only=True).skew() 1.4724267269058975 Notes: The skewness is a measure of the asymmetry of the probability distribution. A perfectly symmetric distribution has a skewness of 0. )rSskewrTs rVr Series.skews%%**,,rYc6URR5$)aCompute the kurtosis (Fisher's definition) without bias correction. Kurtosis is the fourth central moment divided by the square of the variance. The Fisher's definition is used where 3.0 is subtracted from the result to give 0.0 for a normal distribution. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 1, 2, 10, 100]) >>> nw.from_native(s_native, series_only=True).kurtosis() 0.2106571340718002 )rSkurtosisrTs rVrSeries.kurtosiss%%..00rYc6URR5$)zReturns the number of non-null elements in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native(s_native, series_only=True).count() 2 )rScountrTs rVr Series.counts%%++--rYc6URR5$)aqReturn whether any of the values in the Series are True. If there are no non-null elements, the result is `False`. Notes: Only works on Series of data type Boolean. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([False, True, False]) >>> nw.from_native(s_native, series_only=True).any() np.True_ )rSanyrTs rVr Series.anys %%))++rYc6URR5$)a9Return whether all values in the Series are True. If there are no non-null elements, the result is `True`. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[False, True, False]]) >>> nw.from_native(s_native, series_only=True).all() False )rSallrTs rVr Series.all%%))++rYc6URR5$)zGet the minimal value in this Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).min() 1 )rSminrTs rVr Series.min%%))++rYc6URR5$)zGet the maximum value in this Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).max() np.int64(3) )rSmaxrTs rVr  Series.max"r rYc6URR5$)zReturns the index of the minimum value. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).arg_min() 0 )rSarg_minrTs rVrSeries.arg_min/%%--//rYc6URR5$)zReturns the index of the maximum value. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).arg_max() 2 )rSarg_maxrTs rVrSeries.arg_max<rrYc6URR5$)aReduce this Series to the sum value. If there are no non-null elements, the result is zero. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).sum() 6 )rSsumrTs rVr Series.sumIrrYddofc4URRUS9$)a{Get the standard deviation of this Series. Arguments: ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> nw.from_native(s_native, series_only=True).std() 1.0 r)rSstdrUrs rVr Series.stdX%%))t)44rYc4URRUS9$)a{Get the variance of this Series. Arguments: ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native(s_native, series_only=True).var() 1.0 r)rSvarrs rVr Series.varirrYcxUc7URURRURU5S95$Uc7URURR URU5S95$URURR URU5URU5S95$)aClip values in the Series. Arguments: lower_bound: Lower bound value. upper_bound: Upper bound value. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([-1, 1, -3, 3, -5, 5]) >>> nw.from_native(s_native, series_only=True).clip(-1, 3).to_native() 0 -1 1 1 2 -1 3 3 4 -1 5 3 dtype: int64 ) upper_bound) lower_bound)r#r")rrS clip_upperr clip_lowerclip)rUr#r"s rVr& Series.clipzs2  ''&&11 $ 4 4[ A2   ''&&11 $ 4 4[ A2  ##  " " ' ' 00= 00= (   rYc6URR5$)aeGet the first element of the Series. Returns: A scalar value or `None` if the Series is empty. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.first() 1 >>> s_nw.filter(s_nw > 5).first() is None True )rSfirstrTs rVr) Series.firsts"%%++--rYc6URR5$)a5Get the last element of the Series. Returns: A scalar value or `None` if the Series is empty. Notes: Null values are preserved, unless `self` is backed by a non-nullable pandas Series (which does not support missing values). See [boolean columns](../concepts/boolean.md) for reference. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.last() 3 >>> s_nw.filter(s_nw > 5).last() is None True )rSlastrTs rVr, Series.lasts*%%**,,rYc fURURR[USS955$)aCheck if the elements of this Series are in the other sequence. Arguments: other: Sequence of primitive type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.is_in([3, 2, 8]).to_native() # doctest: +ELLIPSIS [ [ false, true, true ] ] T) pass_through)rrSis_inr4rUothers rVr0 Series.is_ins2,##  " " ( (5t)L M  rYcTURURR55$)ayFind elements where boolean Series is True. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, None, None, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).is_null().arg_true().to_native() # doctest: +NORMALIZE_WHITESPACE shape: (2,) Series: '' [u32] [ 1 2 ] )rrSarg_truerTs rVr5Series.arg_trues$$##D$:$:$C$C$EFFrYcTURURR55$)aDrop null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, None, 3, 5]) >>> nw.from_native(s_native, series_only=True).drop_nulls().to_native() 0 2.0 1 4.0 3 3.0 4 5.0 dtype: float64 )rrS drop_nullsrTs rVr8Series.drop_nullss$&##D$:$:$E$E$GHHrYcTURURR55$)aCalculate the absolute value of each element. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[2, -4, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).abs().to_native() # doctest: +ELLIPSIS [ [ 2, 4, 3 ] ] )rrSabsrTs rVr; Series.abss$(##D$:$:$>$>$@AArYreversecRURURRUS95$)a=Calculate the cumulative sum. Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, 3]) >>> nw.from_native(s_native, series_only=True).cum_sum().to_native() 0 2 1 6 2 9 dtype: int64 r=)rrScum_sumrUr>s rVr@Series.cum_sum)s)"##D$:$:$B$B7$B$STTrYmaintain_ordercRURURRUS95$)agReturns unique values of the series. Arguments: maintain_order: Keep the same order as the original series. This may be more expensive to compute. Settings this to `True` blocks the possibility to run on the streaming engine for Polars. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([2, 4, 4, 6]) >>> s = nw.from_native(s_native, series_only=True) >>> s.unique( ... maintain_order=True ... ).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 2 4 6 ] rC)rrSunique)rUrDs rVrF Series.unique<s.2##  " " ) ) ) H  rYcTURURR55$)a Calculate the difference with the previous element, for each element. Notes: pandas may change the dtype here, for example when introducing missing values in an integer column. To ensure, that the dtype doesn't change, you may want to use `fill_null` and `cast`. For example, to calculate the diff and fill missing values with `0` in a Int64 column, you could do: s.diff().fill_null(0).cast(nw.Int64) Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[2, 4, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).diff().to_native() # doctest: +ELLIPSIS [ [ null, 2, -1 ] ] )rrSdiffrTs rVrI Series.diffYs$:##D$:$:$?$?$ABBrYct[U[SS9 URURR U55$)aShift values by `n` positions. Arguments: n: Number of indices to shift forward. If a negative value is passed, values are shifted in the opposite direction instead. Notes: pandas may change the dtype here, for example when introducing missing values in an integer column. To ensure, that the dtype doesn't change, you may want to use `fill_null` and `cast`. For example, to shift and fill missing values with `0` in a Int64 column, you could do: s.shift(1).fill_null(0).cast(nw.Int64) Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([2, 4, 3]) >>> nw.from_native(s_native, series_only=True).shift(1).to_native() 0 NaN 1 2.0 2 4.0 dtype: float64 n) param_name)rrrrSshiftrUrLs rVrN Series.shiftxs26 Ass+##D$:$:$@$@$CDDrY)fractionwith_replacementseedc|[X[U5US9nURURR XSUS95$)aSample randomly from this Series. Arguments: n: Number of items to return. Cannot be used with fraction. fraction: Fraction of items to return. Cannot be used with n. with_replacement: Allow values to be sampled more than once. seed: Seed for the random number generator. If set to None (default), a random seed is generated for each sample operation. Notes: The `sample` method returns a Series with a specified number of randomly selected items chosen from this Series. The results are not consistent across libraries. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3, 4]) >>> s = nw.from_native(s_native, series_only=True) >>> s.sample( ... fraction=1.0, with_replacement=True ... ).to_native() # doctest: +SKIP shape: (4,) Series: '' [i64] [ 1 4 3 4 ] )rLrQheightrR)rLrRrS)rrrrSsample)rUrLrQrRrSsizes rVrV Series.samplesNP$3t9GW ##  " " ) ) *   rYcRURURRUS95$)aRename the Series. Notes: This method is very cheap, but does not guarantee that data will be copied. For example: ```python s1: nw.Series s2 = s1.alias("foo") arr = s2.to_numpy() arr[0] = 999 ``` may (depending on the backend, and on the version) result in `s1`'s data being modified. We recommend: - if you need to alias an object and don't need the original one around any more, just use `alias` without worrying about it. - if you were expecting `alias` to copy data, then explicitly call `.clone` before calling `alias`. Arguments: name: The new name. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="foo") >>> nw.from_native(s_native, series_only=True).alias("bar").to_native() 0 1 1 2 2 3 Name: bar, dtype: int64 ry)rrSrvrUrys rVrv Series.aliass*H##D$:$:$@$@d$@$KLLrYc URUS9$)aRename the Series. Alias for `Series.alias()`. Notes: This method is very cheap, but does not guarantee that data will be copied. For example: ```python s1: nw.Series s2 = s1.rename("foo") arr = s2.to_numpy() arr[0] = 999 ``` may (depending on the backend, and on the version) result in `s1`'s data being modified. We recommend: - if you need to rename an object and don't need the original one around any more, just use `rename` without worrying about it. - if you were expecting `rename` to copy data, then explicitly call `.clone` before calling `rename`. Arguments: name: The new name. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("foo", [1, 2, 3]) >>> s = nw.from_native(s_native, series_only=True) >>> s.rename("bar").to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: 'bar' [i64] [ 1 2 3 ] rZ)rvr[s rVrename Series.renamesTzztz$$rY)default return_dtypec UcT[U[5(d Sn[U5e[UR 55n[UR 55n[U[ 5(de[U[ 5(deURURRUUURU5US95$)aReplace all values by different values. Arguments: old: Sequence of values to replace. It also accepts a mapping of values to their replacement as syntactic sugar for `replace_strict(old=list(mapping.keys()), new=list(mapping.values()))`. new: Sequence of values to replace by. Length must match the length of `old`. default: Set values that were not replaced to this value. If no default is specified, (default), an error is raised if any values were not replaced. Accepts expression input. Non-expression inputs are parsed as literals. return_dtype: The data type of the resulting expression. If set to `None` (default), the data type is determined automatically based on the other inputs. Raises: InvalidOperationError: If any non-null values in the original column were not replaced, and no default was specified. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([3, 0, 1, 2], name="a") >>> nw.from_native(s_native, series_only=True).replace_strict( ... [0, 1, 2, 3], ["zero", "one", "two", "three"], return_dtype=nw.String ... ).to_native() 0 three 1 zero 2 one 3 two Name: a, dtype: str Replace values and set a default for values not in the mapping: >>> s_native = pd.Series([1, 2, 3, 4], name="a") >>> s_default = pd.Series(["beluga", "narwhal", "orca", "vaquita"]) >>> nw.from_native(s_native, series_only=True).replace_strict( ... {1: "one", 2: "two"}, ... default=nw.from_native(s_default, series_only=True), ... return_dtype=nw.String, ... ).to_native() 0 one 1 two 2 orca 3 vaquita Name: a, dtype: str zB`new` argument is required if `old` argument is not a Mapping type)oldnewr`ra) rrrlistrzkeysrrrSreplace_strictr)rUrcrdr`rarjs rVrgSeries.replace_strictsn ;c7++Zn$szz|$Csxxz"C#x((((#x((((##  " " 1 1,,W5) 2   rY descending nulls_lastcRURURRXS95$)aSort this Series. Place null values first. Arguments: descending: Sort in descending order. nulls_last: Place null values last instead of first. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([5, None, 1, 2]) >>> s = nw.from_native(s_native, series_only=True) >>> s.sort(descending=True).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (4,) Series: '' [i64] [ null 5 2 1 ] ri)rrSsort)rUrjrks rVrm Series.sortes..##  " " ' ': ' U  rYcTURURR55$)a6Returns a boolean Series indicating which values are null. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, None]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_null().to_native() # doctest:+ELLIPSIS [ [ false, false, true ] ] )rrSis_nullrTs rVrpSeries.is_nulls$0##D$:$:$B$B$DEErYcTURURR55$)aReturns a boolean Series indicating which values are NaN. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([0.0, None, 2.0], dtype="Float64") >>> nw.from_native(s_native, series_only=True).is_nan().to_native() 0 False 1 2 False dtype: boolean )rrSis_nanrTs rVrs Series.is_nans$$##D$:$:$A$A$CDDrYcUbUb Sn[U5eUcUc Sn[U5eUbUS;aSU3n[U5eURURRUR U5X#S95$)a$Fill null values using the specified value. Arguments: value: Value used to fill null values. strategy: Strategy used to fill null values. limit: Number of consecutive null values to fill when using the 'forward' or 'backward' strategy. Notes: - pandas handles null values differently from other libraries. See [null_handling](../concepts/null_handling.md) for reference. - For pandas Series of `object` dtype, `fill_null` will not automatically change the Series' dtype as pandas used to do. Explicitly call `cast` if you want the dtype to change. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, None]) >>> >>> nw.from_native(s_native, series_only=True).fill_null(5).to_native() 0 1.0 1 2.0 2 5.0 dtype: float64 Or using a strategy: >>> nw.from_native(s_native, series_only=True).fill_null( ... strategy="forward", limit=1 ... ).to_native() 0 1.0 1 2.0 2 2.0 dtype: float64 z*cannot specify both `value` and `strategy`z0must specify either a fill `value` or `strategy`>forwardbackwardzstrategy not supported: )valuestrategylimit)rqrrS fill_nullr)rUrxryrzrjs rVr{Series.fill_nullsT  !5>CS/ ! =X-DCS/ !  H4K$K,XJ7CS/ !##  " " , ,**51H -   rYcpURURRURU5S95$)aFill floating point NaN values with given value. Arguments: value: Value used to fill NaN values. Notes: This function only fills `'NaN'` values, not null ones, except for pandas which doesn't distinguish between them. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import polars as pl >>> import narwhals as nw >>> s_native = pl.Series([1.0, 2.0, float("nan"), None]) >>> result = nw.from_native(s_native, series_only=True).fill_nan(0) >>> result.to_native() # doctest: +NORMALIZE_WHITESPACE shape: (4,) Series: '' [f64] [ 1.0 2.0 0.0 null ] )rx)rrSfill_nanr)rUrxs rVr~Series.fill_nans94##  " " + +$2F2Fu2M + N  rYcURURRURU5URU5US95$)aPGet a boolean mask of the values that are between the given lower/upper bounds. Arguments: lower_bound: Lower bound value. upper_bound: Upper bound value. closed: Define which sides of the interval are closed (inclusive). Options are {"left", "right", "none", "both"}. Notes: If the value of the `lower_bound` is greater than that of the `upper_bound`, then the values will be False, as no value can satisfy the condition. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 4, 5]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.is_between(2, 4, "right").to_native() # doctest: +ELLIPSIS [ [ false, false, true, true, false ] ] )closed)rrS is_betweenr)rUr#r"rs rVrSeries.is_betweensPF##  " " - -$$[1$$[1 .   rYc6URR5$)zCount the number of unique values. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 2, 3]) >>> nw.from_native(s_native, series_only=True).n_unique() 3 )rSn_uniquerTs rVrSeries.n_unique0s%%..00rYc6URRSSS9$)zConvert to numpy. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="a") >>> nw.from_native(s_native, series_only=True).to_numpy() array([1, 2, 3]...) N)r)rSto_numpyrTs rVrSeries.to_numpy=s %%..t$.??rYc6URR5$)aConvert to pandas Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series("a", [1, 2, 3]) >>> nw.from_native(s_native, series_only=True).to_pandas() 0 1 1 2 2 3 Name: a, dtype: int64 )rS to_pandasrTs rVrSeries.to_pandasJs%%//11rYc6URR5$)a_Convert to polars Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3]]) >>> nw.from_native( ... s_native, series_only=True ... ).to_polars() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [i64] [ 1 2 3 ] )rS to_polarsrTs rVrSeries.to_polarsZs&%%//11rYctURURRURU555$rR)rrS__add__rr1s rVrSeries.__add__o4##  " " * *4+?+?+F G  rYctURURRURU555$rR)rrS__radd__rr1s rVrSeries.__radd__t4##  " " + +D,@,@,G H  rYctURURRURU555$rR)rrS__sub__rr1s rVrSeries.__sub__yrrYctURURRURU555$rR)rrS__rsub__rr1s rVrSeries.__rsub__~rrYctURURRURU555$rR)rrS__mul__rr1s rVrSeries.__mul__rrYctURURRURU555$rR)rrS__rmul__rr1s rVrSeries.__rmul__rrYctURURRURU555$rR)rrS __truediv__rr1s rVrSeries.__truediv__s4##  " " . .t/C/CE/J K  rYctURURRURU555$rR)rrS __rtruediv__rr1s rVrSeries.__rtruediv__4##  " " / /0D0DU0K L  rYctURURRURU555$rR)rrS __floordiv__rr1s rVrSeries.__floordiv__rrYctURURRURU555$rR)rrS __rfloordiv__rr1s rVrSeries.__rfloordiv__s4##  " " 0 01E1Ee1L M  rYctURURRURU555$rR)rrS__pow__rr1s rVrSeries.__pow__rrYctURURRURU555$rR)rrS__rpow__rr1s rVrSeries.__rpow__rrYctURURRURU555$rR)rrS__mod__rr1s rVrSeries.__mod__rrYctURURRURU555$rR)rrS__rmod__rr1s rVrSeries.__rmod__rrYctURURRURU555$rR)rrS__eq__rr1s rVr Series.__eq__4##  " " ) )$*>*>u*E F  rYctURURRURU555$rR)rrS__ne__rr1s rVr Series.__ne__rrYctURURRURU555$rR)rrS__gt__rr1s rVr Series.__gt__rrYctURURRURU555$rR)rrS__ge__rr1s rVr Series.__ge__rrYctURURRURU555$rR)rrS__lt__rr1s rVr Series.__lt__rrYctURURRURU555$rR)rrS__le__rr1s rVr Series.__le__rrYctURURRURU555$rR)rrS__and__rr1s rVrSeries.__and__rrYctURURRURU555$rR)rrS__rand__rr1s rVrSeries.__rand__rrYctURURRURU555$rR)rrS__or__rr1s rVr Series.__or__rrYctURURRURU555$rR)rrS__ror__rr1s rVrSeries.__ror__rrYcTURURR55$rR)rrS __invert__rTs rVrSeries.__invert__s"##D$:$:$E$E$GHHrYcTURURR55$rR)rrS__neg__rTs rVrSeries.__neg__s"##D$:$:$B$B$DEErYctURURRURU555$)aMFilter elements in the Series based on a condition. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([4, 10, 15, 34, 50]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.filter(s_nw > 10).to_native() 2 15 3 34 4 50 dtype: int64 )rrSfilterr)rU predicates rVr Series.filters6##  " " ) )$*>*>y*I J  rYcTURURR55$)aGet a mask of all duplicated rows in the Series. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 1]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_duplicated().to_native() # doctest: +ELLIPSIS [ [ true, false, false, true ] ] )rrS is_duplicatedrTs rVrSeries.is_duplicateds$*##D$:$:$H$H$JKKrYc6URR5$)a#Check if the series is empty. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.is_empty() False >>> s_nw.filter(s_nw > 10).is_empty() True )rSrrTs rVrSeries.is_emptys%%..00rYcTURURR55$)a<Get a mask of all unique rows in the Series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3, 1]) >>> nw.from_native(s_native, series_only=True).is_unique().to_native() 0 False 1 True 2 True 3 False dtype: bool )rrS is_uniquerTs rVrSeries.is_unique*s$##D$:$:$D$D$FGGrYc6URR5$)a}Count the number of null values. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, None, None]]) >>> nw.from_native(s_native, series_only=True).null_count() 2 )rS null_countrTs rVrSeries.null_count;s%%0022rYcTURURR55$)aReturn a boolean mask indicating the first occurrence of each distinct value. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 1, 2, 3, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).is_first_distinct().to_native() # doctest: +NORMALIZE_WHITESPACE shape: (5,) Series: '' [bool] [ true false true true false ] )rrSis_first_distinctrTs rVrSeries.is_first_distinctLs$*##D$:$:$L$L$NOOrYcTURURR55$)auReturn a boolean mask indicating the last occurrence of each distinct value. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 1, 2, 3, 2]) >>> nw.from_native(s_native, series_only=True).is_last_distinct().to_native() 0 False 1 True 2 False 3 True 4 True dtype: bool )rrSis_last_distinctrTs rVrSeries.is_last_distinctcs$ ##D$:$:$K$K$MNNrYrjc4URRUS9$)aCheck if the Series is sorted. Arguments: descending: Check if the Series is sorted in descending order. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[3, 2, 1]]) >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.is_sorted(descending=False) False >>> s_nw.is_sorted(descending=True) True r)rS is_sorted)rUrjs rVrSeries.is_sortedus&%%//:/FFrYrmparallelry normalizec fURURRXX4S9URS9$)aCount the occurrences of unique values. Arguments: sort: Sort the output by count in descending order. If set to False (default), the order of the output is random. parallel: Execute the computation in parallel. Used for Polars only. name: Give the resulting count column a specific name; if `normalize` is True defaults to "proportion", otherwise defaults to "count". normalize: If true gives relative frequencies of the unique values - The original values as first column - Either count or proportion as second column, depending on normalize parameter. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 1, 2, 3, 2], name="s") >>> nw.from_native(s_native, series_only=True).value_counts( ... sort=True ... ).to_native() s count 0 1 2 1 2 2 2 3 1 rro)r\rS value_countsre)rUrmrryrs rVrSeries.value_countssBD  " " / /4 0 ++   rYc4URRXS9$)aAGet quantile value of the series. Note: pandas and Polars may have implementation differences for a given interpolation method. Arguments: quantile: Quantile between 0.0 and 1.0. interpolation: Interpolation method. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series(list(range(50))) >>> s_nw = nw.from_native(s_native, series_only=True) >>> [ ... s_nw.quantile(quantile=q, interpolation="nearest") ... for q in (0.1, 0.25, 0.5, 0.75, 0.9) ... ] [5.0, 12.0, 25.0, 37.0, 44.0] )quantile interpolation)rSr)rUrrs rVrSeries.quantiles%0%%../  rYcURURRURU5URU555$)aTake values from self or other based on the given mask. Where mask evaluates true, take values from self. Where mask evaluates false, take values from other. Arguments: mask: Boolean Series other: Series of same type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> data_native = pa.chunked_array([[1, 2, 3, 4, 5]]) >>> other_native = pa.chunked_array([[5, 4, 3, 2, 1]]) >>> mask_native = pa.chunked_array([[True, False, True, False, True]]) >>> >>> data_nw = nw.from_native(data_native, series_only=True) >>> other_nw = nw.from_native(other_native, series_only=True) >>> mask_nw = nw.from_native(mask_native, series_only=True) >>> >>> data_nw.zip_with(mask_nw, other_nw).to_native() # doctest: +ELLIPSIS [ [ 1, 4, 3, 2, 5 ] ] )rrSzip_withr)rUmaskr2s rVrSeries.zip_withsGB##  " " + +$$T*D,@,@,G   rYcUb+U[U5:aSUS[U53n[U5eURRUS9$)aReturn the Series as a scalar, or return the element at the given index. If no index is provided, this is equivalent to `s[0]`, with a check that the shape is (1,). With an index, this is equivalent to `s[index]`. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> nw.from_native(pl.Series("a", [1]), series_only=True).item() 1 >>> nw.from_native(pl.Series("a", [9, 8, 7]), series_only=True).item(-1) 7 zindex z# out of range for series of length )index)r IndexErrorrSr)rUr rjs rVr Series.itemsP  #d)!35'!DSYKPCS/ !%%***77rYcVURURRU55$)a9Get the first `n` rows. Arguments: n: Number of rows to return. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series(list(range(10))) >>> nw.from_native(s_native, series_only=True).head(3).to_native() 0 0 1 1 2 2 dtype: int64 )rrSheadrOs rVr Series.head s&"##D$:$:$?$?$BCCrYcVURURRU55$)aGet the last `n` rows. Arguments: n: Number of rows to return. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([list(range(10))]) >>> s = nw.from_native(s_native, series_only=True) >>> s.tail(3).to_native() # doctest: +ELLIPSIS [ [ 7, 8, 9 ] ] )rrStailrOs rVr Series.tails&,##D$:$:$?$?$BCCrYcVURURRU55$)a/Round underlying floating point data by `decimals` digits. Arguments: decimals: Number of decimals to round by. Notes: For values exactly halfway between rounded decimal values pandas behaves differently than Polars and Arrow. pandas rounds to the nearest even value (e.g. -0.5 and 0.5 round to 0.0, 1.5 and 2.5 round to 2.0, 3.5 and 4.5 to 4.0, etc..). Polars and Arrow round away from 0 (e.g. -0.5 to -1.0, 0.5 to 1.0, 1.5 to 2.0, 2.5 to 3.0, etc..). Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1.12345, 2.56789, 3.901234]) >>> s = nw.from_native(s_native, series_only=True) >>> s.round(1).to_native() # doctest: +NORMALIZE_WHITESPACE shape: (3,) Series: '' [f64] [ 1.1 2.6 3.9 ] )rrSround)rUdecimalss rVr Series.round6s&:##D$:$:$@$@$JKKrYcTURURR55$)aoCompute the numerical floor. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> s_native = pa.chunked_array([[1.1, 4.3, -1.3]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.floor().to_native() # doctest:+ELLIPSIS [ [ 1, 4, -2 ] ] )rrSfloorrTs rVr Series.floorUs$$##D$:$:$@$@$BCCrYcTURURR55$)apCompute the numerical ceiling. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> s_native = pa.chunked_array([[1.1, 4.3, -1.3]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.ceil().to_native() # doctest:+ELLIPSIS [ [ 2, 5, -1 ] ] )rrSceilrTs rVr Series.ceili$$##D$:$:$?$?$ABBrY_ separator drop_firstcdURURRXS9URS9$)aGet dummy/indicator variables. Arguments: separator: Separator/delimiter used when generating column names. drop_first: Remove the first category from the variable being encoded. Notes: pandas and Polars handle null values differently. Polars distinguishes between NaN and Null, whereas pandas doesn't. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1, 2, 3], name="a") >>> s_nw = nw.from_native(s_native, series_only=True) >>> s_nw.to_dummies(drop_first=False).to_native() a_1 a_2 a_3 0 1 0 0 1 0 1 0 2 0 0 1 >>> s_nw.to_dummies(drop_first=True).to_native() a_2 a_3 0 0 0 1 1 0 2 0 1 rro)r\rS to_dummiesre)rUr r!s rVr#Series.to_dummies}s9@  " " - - - Y++  rYcRURURRXS95$)aTake every nth value in the Series and return as new Series. Arguments: n: Gather every *n*-th row. offset: Starting index. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 2, 3, 4]]) >>> nw.from_native(s_native, series_only=True).gather_every( ... n=2, offset=1 ... ).to_native() # doctest:+ELLIPSIS [ [ 2, 4 ] ] )rLoffset)rrS gather_every)rUrLr&s rVr'Series.gather_everys..##  " " / /! / C  rYc6URR5$)aaConvert to arrow. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 2, 3, 4]) >>> nw.from_native( ... s_native, series_only=True ... ).to_arrow() # doctest:+NORMALIZE_WHITESPACE [ 1, 2, 3, 4 ] )rSrrTs rVrSeries.to_arrows&%%..00rYrkeepcgrRrrUr,s rVmode Series.modes=@rYcgrRrr.s rVr/r0sADrYcSnX;aSUSUS3n[U5eURURRUS95nUS:XaUR S5$U$)a@Compute the most occurring value(s). Can return multiple values. Note: For `keep="any"` a scalar is returned, while for `keep="all"` a Series in returned even in the case of unimodal values. Arguments: keep: Whether to keep all modes or any mode found. Remark that `keep='any'` is not deterministic for multimodal values. Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 1, 2, 2, 3]) >>> nw.from_native(s_native, series_only=True).mode().sort().to_native() 0 1 1 2 dtype: int64 )rrz`keep` must be one of z , found ''r+rr)rqrrSr/r)rUr,_supported_keep_valuesrjrs rVr/r0sn,"0  -*+A*B)D6QRSCS/ !%%d&<&<&A&At&A&LM!%v{{1~:F:rYcTURURR55$)aReturns a boolean Series indicating which values are finite. Warning: Different backend handle null values differently. `is_finite` will return False for NaN and Null's in the Dask and pandas non-nullable backend, while for Polars, PyArrow and pandas nullable backends null values are kept as such. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[float("nan"), float("inf"), 2.0, None]]) >>> nw.from_native( ... s_native, series_only=True ... ).is_finite().to_native() # doctest: +ELLIPSIS [ [ false, false, true, null ] ] )rrS is_finiterTs rVr6Series.is_finites$4##D$:$:$D$D$FGGrYcRURURRUS95$)aReturn the cumulative count of the non-null values in the series. Arguments: reverse: reverse the operation Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series(["x", "k", None, "d"]) >>> nw.from_native(s_native, series_only=True).cum_count( ... reverse=True ... ).to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [u32] [ 3 2 1 1 ] r=)rrS cum_countrAs rVr9Series.cum_count s).##D$:$:$D$DW$D$UVVrYcRURURRUS95$)azReturn the cumulative min of the non-null values in the series. Arguments: reverse: reverse the operation Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([3, 1, None, 2]) >>> nw.from_native(s_native, series_only=True).cum_min().to_native() 0 3.0 1 1.0 2 NaN 3 1.0 dtype: float64 r=)rrScum_minrAs rVr<Series.cum_min+ s)$##D$:$:$B$B7$B$STTrYcRURURRUS95$)aReturn the cumulative max of the non-null values in the series. Arguments: reverse: reverse the operation Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1, 3, None, 2]]) >>> nw.from_native( ... s_native, series_only=True ... ).cum_max().to_native() # doctest:+ELLIPSIS [ [ 1, 3, null, 3 ] ] r=)rrScum_maxrAs rVr?Series.cum_max? s)0##D$:$:$B$B7$B$STTrYcRURURRUS95$)aReturn the cumulative product of the non-null values in the series. Arguments: reverse: reverse the operation Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1, 3, None, 2]) >>> nw.from_native( ... s_native, series_only=True ... ).cum_prod().to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [i64] [ 1 3 null 6 ] r=)rrScum_prodrAs rVrBSeries.cum_prodY s).##D$:$:$C$CG$C$TUUrY)rcenterc[XS9up[U5S:XaU$URURR XUS95$)aApply a rolling sum (moving sum) over the values. 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.0, 2.0, 3.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_sum( ... window_size=2 ... ).to_native() 0 NaN 1 3.0 2 5.0 3 7.0 dtype: float64  window_sizerrrGrrD)rrrrS rolling_sum)rUrGrrDmin_samples_ints rVrISeries.rolling_sumr sYD(C#( $  t9>K##  " " . .'V /   rYc[XS9up[U5S:XaU$URURR XUS95$)amApply a rolling mean (moving mean) over the values. 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. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[1.0, 2.0, 3.0, 4.0]]) >>> nw.from_native(s_native, series_only=True).rolling_mean( ... window_size=2 ... ).to_native() # doctest:+ELLIPSIS [ [ null, 1.5, 2.5, 3.5 ] ] rFrrH)rrrrS rolling_mean)rUrGrrDs rVrMSeries.rolling_mean sXL$?#$   t9>K##  " " / /' 0   rY)rrDrc [XS9up[U5S:XaU$URURR XX4S95$)aApply a rolling variance (moving variance) over the values. 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. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> s_native = pl.Series([1.0, 3.0, 1.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_var( ... window_size=2, min_samples=1 ... ).to_native() # doctest:+NORMALIZE_WHITESPACE shape: (4,) Series: '' [f64] [ null 2.0 2.0 4.5 ] rFrrGrrDr)rrrrS rolling_varrUrGrrDrs rVrQSeries.rolling_var sXV$?#$   t9>K##  " " . .' /   rYc [XS9up[U5S:XaU$URURR XX4S95$)aApply a rolling standard deviation (moving standard deviation) over the values. 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. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> s_native = pd.Series([1.0, 3.0, 1.0, 4.0]) >>> nw.from_native(s_native, series_only=True).rolling_std( ... window_size=2, min_samples=1 ... ).to_native() 0 NaN 1 1.414214 2 1.414214 3 2.121320 dtype: float64 rFrrP)rrrrS rolling_stdrRs rVrUSeries.rolling_std sXP$?#$   t9>K##  " " . .' /   rYc#T# URR5ShvN gN7frR)rS__iter__rTs rVrXSeries.__iter__A s))22444s (&(c8URRU5$rR)rS __contains__r1s rVr[Series.__contains__D s%%22599rYc1SknX;aSUS3n[U5eURURRXS95$)aAssign ranks to data, dealing with ties appropriately. Notes: The resulting dtype may differ between backends. Arguments: method: The method used to assign ranks to tied elements. The following methods are available (default is 'average') - *"average"*: The average of the ranks that would have been assigned to all the tied values is assigned to each value. - *"min"*: The minimum of the ranks that would have been assigned to all the tied values is assigned to each value. (This is also referred to as "competition" ranking.) - *"max"*: The maximum of the ranks that would have been assigned to all the tied values is assigned to each value. - *"dense"*: Like "min", but the rank of the next highest element is assigned the rank immediately after those assigned to the tied elements. - *"ordinal"*: All values are given a distinct rank, corresponding to the order that the values occur in the Series. descending: Rank in descending order. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> s_native = pa.chunked_array([[3, 6, 1, 1, 6]]) >>> nw.from_native(s_native, series_only=True).rank( ... method="dense" ... ).to_native() # doctest:+ELLIPSIS [ [ 2, 3, 1, 1, 3 ] ] >r rdenseaverageordinalzTRanking method must be one of {'average', 'min', 'max', 'dense', 'ordinal'}. Found 'r3)methodrj)rqrrSrank)rUrarjsupported_rank_methodsrjs rVrb Series.rankG s^V"O  / $ S/ !##  " " ' 'v ' M  rY bin_countinclude_breakpointc Z^Tbm[U4Sj[S[T5555(a Sn[U5eUbSU<ST<3n[U5eURR TUS9nO"SnUcUOUnURR X#S9nURXPRS 9$) uBin values into buckets and count their occurrences. Warning: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Arguments: bins: A monotonically increasing sequence of values. bin_count: If no bins provided, this will be used to determine the distance of the bins. include_breakpoint: Include a column that shows the intervals as categories. Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 3, 8, 8, 2, 1, 3], name="a") >>> nw.from_native(s_native, series_only=True).hist(bin_count=4) ┌────────────────────┐ | Narwhals DataFrame | |--------------------| | breakpoint count| |0 2.75 3| |1 4.50 2| |2 6.25 0| |3 8.00 2| └────────────────────┘ c3@># UHnTUS- TU:v M g7f)rNr).0rbinss rV Series.hist.. s$G3Fa4A;$q')3Fsrz bins must increase monotonicallyz>can only provide one of `bin_count` or `bins`, got: bin_count=z, bins=)rkrg rero) rrangerr&rShist_from_binshist_from_bin_countr\re)rUrkrfrgrjrr`s ` rVhist Series.hist~ sB  G5CI3FGGG8"3''$WYLX`[_Zab"3''++::.@;F G#,#4)I++??#@Fv[[99rYcRURURRUS95$)uqCompute the logarithm to a given base. Arguments: base: Given base, defaults to `e` Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 2, 4], name="a") >>> s = nw.from_native(s_native, series_only=True) >>> s.log(base=2) ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 0.0 | |1 1.0 | |2 2.0 | |Name: a, dtype: float64| └───────────────────────┘ )base)rrSlog)rUrus rVrv Series.log s)*##D$:$:$>$>D$>$IJJrYcTURURR55$)u)Compute the exponent. Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([-1, 0, 1], name="a") >>> s = nw.from_native(s_native, series_only=True) >>> s.exp() ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 0.367879 | |1 1.000000 | |2 2.718282 | |Name: a, dtype: float64| └───────────────────────┘ )rrSexprTs rVry Series.exp s$$##D$:$:$>$>$@AArYcTURURR55$)uiCompute the element-wise value for the sine. Examples: >>> import pandas as pd >>> import narwhals as nw >>> from math import pi >>> s_native = pd.Series([0, pi / 2, 3 * pi / 2], name="a") >>> s = nw.from_native(s_native, series_only=True) >>> s.sin() ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 0.0 | |1 1.0 | |2 -1.0 | |Name: a, dtype: float64| └───────────────────────┘ )rrSsinrTs rVr| Series.sin $&##D$:$:$>$>$@AArYcTURURR55$)utCompute the element-wise value for the cosine. Examples: >>> import pandas as pd >>> import narwhals as nw >>> from math import pi >>> s_native = pd.Series([0, pi / 2, 3 * pi / 2], name="a") >>> s = nw.from_native(s_native, series_only=True) >>> s.cos().round(4) ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 1.0 | |1 0.0 | |2 -0.0 | |Name: a, dtype: float64| └───────────────────────┘ )rrScosrTs rVr Series.cos r~rYcTURURR55$)u,Compute the square root. Examples: >>> import pandas as pd >>> import narwhals as nw >>> s_native = pd.Series([1, 4, 9], name="a") >>> s = nw.from_native(s_native, series_only=True) >>> s.sqrt() ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 1.0 | |1 2.0 | |2 3.0 | |Name: a, dtype: float64| └───────────────────────┘ )rrSsqrtrTs rVr Series.sqrt rrYgg& .>abs_tolrel_tol nans_equalcURR5(dSURS3n[U5eURnUSLnU(aSOUn[ U5R XX4S9n U(aUR U5OUn U R5RU 5RU5n U(aU R U5OU n [SU 5$)aGet a boolean mask of the values being close to the other values. Two values `a` and `b` are considered close if the following condition holds: $$ |a-b| \le max \{ \text{rel\_tol} \cdot max \{ |a|, |b| \}, \text{abs\_tol} \} $$ Arguments: other: Values to compare with. abs_tol: Absolute tolerance. This is the maximum allowed absolute difference between two values. Must be non-negative. rel_tol: Relative tolerance. This is the maximum allowed difference between two values, relative to the larger absolute value. Must be in the range [0, 1). nans_equal: Whether NaN values should be considered equal. Notes: The implementation of this method is symmetric and mirrors the behavior of `math.isclose`. Specifically note that this behavior is different to `numpy.isclose`. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = [1.0, float("inf"), 1.41, None, float("nan")] >>> s_native = pa.chunked_array([data]) >>> s = nw.from_native(s_native, series_only=True) >>> s.is_close(1.4, abs_tol=0.1).to_native() # doctest:+ELLIPSIS [ [ false, false, true, null, false ] ] z.`is_close` operation not supported for dtype `z7` Hint: `is_close` is only supported for numeric typesN__nw_is_close__rr8) r{ is_numericr'ryr)is_closer^rselect get_columnr) rUr2rrrrj orig_name name_is_nonetmp_nameexprr_rs rVrSeries.is_close sbzz$$&&@ MGG (, ,II  D( (4$)8}%% G& +7X&D"))$/::8D-9y)vFF##rYrc4URRUS9$)aGGet a random value from the column. Warning: This functionality is considered **unstable** as it diverges from the polars API. It may be changed at any point without it being considered a breaking change. Arguments: ignore_nulls: Whether to ignore null values or not. If `True` and there are no not-null elements, then `None` is returned. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> s_native = pa.chunked_array([[1, 2, None]]) >>> s = nw.from_native(s_native, series_only=True) >>> s.any_value(ignore_nulls=True) 1 r)rS any_value)rUrs rVrSeries.any_value` s(%%//\/JJrYc[U5$rRr0rTs rVr Series.strv $T**rYc[U5$rRr,rTs rVdt Series.dtz s &t,,rYc[U5$rRr*rTs rVcat Series.cat~ s !$''rYc[U5$rRr.rTs rVre Series.list s "4((rYc[U5$rRr2rTs rVstruct Series.struct rrY)rSre)returnzCompliantSeries[IntoSeriesT])rztype[DataFrame[Any]])rr()r_r riz&Literal['full', 'lazy', 'interchange']rNonerR) ryrrzrLr{IntoDType | Noner|&IntoBackend[EagerAllowed | PluginName]r Series[Any]) ryrrzz Iterable[Any]r{rr|rrr)rr7)NN)r{r rz bool | NonerrL)rrJrr )rr?rr8)rz(SingleIndexSelector | MultiIndexSelectorr Any | Self)rr6)rz object | Nonerobject)rr5)rzSelf | Iterable[int] | intrzz.Self | Iterable[PythonLiteral] | PythonLiteralrr8)rz tuple[int])rr rr )r_r rr8)rzCallable[[Any], Self]rr rr rr8)rr)rr)rr@)r float | Nonerrrrrrrboolrrrrrr8)r{rCrr8)rDataFrame[Any])rz list[Any])rfloat)rr)rr)rr )rrrr)r#.Self | NumericLiteral | TemporalLiteral | Noner"rrr8)rrG)r2r rr8)rr8)r>rrr8)rDrrr8)rLrrr8) rL int | NonerQrrRrrSrrr8)ryrrr8) rcz!Sequence[Any] | Mapping[Any, Any]rdzSequence[Any] | Noner`zAny | NoDefaultrarrr8)rjrrkrrr8)NNN)rxSelf | NonNestedLiteralryzFillNullStrategy | Nonerzrrr8)rxrrr8)both)r#rr"rrrArr8)rrL)rzpd.Series[Any])rz pl.Series)r2rrr8)rr rr8)rjrrr) rmrrrryz str | Nonerrrr)rrrrIrr)rr8r2r8rr8)r rrr )rn)r)rrrr8)r rr!rrr)rLrr&rrr8)rz pa.Array[Any])r,zLiteral['all']rr8)r,zLiteral['any']rrE)r,rDrr)rGrrrrDrrr8) rGrrrrDrrrrr8)rz Iterator[Any])r2r rr)r_)rarHrjrrr8)rkzlist[float] | Nonerfrrgrrr)rurrr8) r2zSelf | NumericLiteralrrrrrrrr8)rrrrG)rzSeriesStringNamespace[Self])rzSeriesDateTimeNamespace[Self])rzSeriesCatNamespace[Self])rzSeriesListNamespace[Self])rzSeriesStructNamespace[Self])__name__ __module__ __qualname____firstlineno____doc__rMAINrP__annotations__propertyrWr\rark classmethodrurrr}rrrrrrr4rrrrrrrrr{ryrrrrrrrrrrrrr rrrrrr&r)r,r0r5r8r;r@rFrIrNrVrvr^rrgrmrprsr{r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr#r'rr/r6r9r<r?rBrIrMrQrUrXr[rbrrmathervryr|rrrr rrrrrer__static_attributes__rrYrVrNrNCsC(#*,,H. &&  & &%K &  & #' >>> > 8 > >>@ #' ;;; ; 8 ; ;;z'6&7NO7( H?? ??5An=H6-&A,+A,?A,  A,F / / 9/&M+ + , , + + !!"&""D D  D  D  D D D D  D LH0U*0& -/ -"1 .,$ , , , 0 0 ,"#5""#5&GKFJ* C* D*   * X.&-. 4G(I*B,*/U&05 :C>EB/ "&!& / /  /  /  /  / b$ML*%^%)I $.)- I .I "I ! I ' I  I V*/5 6F4E,*.,0 7 &7 *7  7  7 r D"( ) )  )  )  ) V 1 @2 2*                        IF (L.1"H"3"P.O$/4G0 ' '  '  '  '  ' R  .H  8% N8*D&D0L>D(C*#&%# # 37# # J 61*-2@@ DD/4;<H8,1W2*/U(*/U4+0V4>BRW- - 0:- KO- - `>BRW1 1 0:1 KO1 1 n#' 6 6  6  6  6  6 x#' 3 3  3  3  3  3 j5:5 5 5 r$(3:!%#' 3: 3: 3: ! 3:  3:j!%K.B(B*B*C0 B$$B$ B$  B$  B$ B$H05KK*++--(())++rYrN)d __future__rrcollections.abcrrrrr functoolsr typingr r r r rrrnarwhals._expression_parsingrrnarwhals._utilsrrrrrrrrrrrrrr narwhals.dependenciesr!r"r#narwhals.dtypesr$r%narwhals.exceptionsr&r' narwhals.exprr(narwhals.functionsr)narwhals.series_catr+narwhals.series_dtr-narwhals.series_listr/narwhals.series_strr1narwhals.series_structr3narwhals.translater4narwhals.typingr5typesr6r7pandaspdpolarsplpyarrowpatyping_extensionsr8narwhals._compliantr9narwhals._typingr:r;r<r=r[r>r?r@rArBrCrDrErFrGrHrIrJrKrLrNrrYrVrs" KKQQQ; UTAC"26458(' &3QQ@%     E-+W[ !E-+rY