h$SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS K Jr SS KrSS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r! SSK"J#r$ SSK"J%r& SSK"J'r' SSK"J(r( SSK"J)r) SSK"J*r* SSK"J+r+ SSK"J,r, SSK"J-r- SSK"J.r. SS K"J/r/ SS!K"J0r0 SS"K"J1r2 SS#K3J4r5 SS$K6J7r8 SS%K9J:r: SS&K;Jr> SS)K;J?r? SS*K;J@r@ SS+K;JArA SS,K;JBrB SS-K;JCrC SS.K;JDrD SS/K;JErE SS0K;JFrF SS1K;JGrG SS2K;JHrH SS3K;JIrI SS4K;JJrJ SS5K;JKrK SS6K;JLrL SS7K;JMrM SS8K;JNrN SS9K;JOrO SS:K;JPrP SS;K;JQrQ SSK;JTrT SS?K;JUrU SS@K;JVrV SSAK;JWrW SSBKXJYrY SSCKXJZrZ SSDKXJ[r[ SSEK\J]r] SSFK\J^r^ SSGK_J`r` SSHK_Jara SSIK_Jbrb SSJK_Jcrc SSKK_Jdrd SSLK_Jere SSMK_Jfrf SSNK_Jgrg SSOK_Jhrh SSPK_Jiri SSQK_Jjrj SSRK_Jkrk \(aSSSKlJmrm SSTKJnrn SSUKoJprp SSVKoJqrq SSWKrJsrs SSXKJtrt SSYKJuru SSZKvJwrw SS[K\Jxrx SS\K\Jyry SS]K\Jzrz SS^K\J{r{ SS_K\J|r| SS`K\J}r} SSaK\J~r~ SSbK\Jr SScK\Jr SSdK\Jr \q"SeSfSg5r\q"ShSfSi9r\q"SjSgSi9r\q"SkSlSi9r\q"SmSn\So9r\q"Sp\Sq9rOSSVKJqrq \q"SmSnSi9r\q"Sp5r"SrSs\\]5r"StSu\\^5r"SvSw\8\5r7"SxSy\!5r "SzS{\55r4\ SS|j5r\ SS}j5r\ SS~j5r\ SSj5r\ SSj5rSSjr\ SSj5r\ SSj5r\ SSj5r\ SSj5r\ SSS.SSjj5r\ SSS.SSjj5r\ SSSS.SSjj5r\ SSSS.SSjj5r\ SSSS.SSjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSSS.GS Sjj5r\ SSSSSS.GS Sjj5r\ SSS.GS Sjj5r\ SSS.GS Sjj5r\ SSSS.GS Sjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSS.GSSjj5r\ SSSSSS.GSSjj5r\ SS.GSSjj5rS S SSSS S.GSSjjr\ SS.GSSjj5r\ SS.GSSjj5r\ SS.GSSjj5r\ GSSj5r\ SS.GS Sjj5r\ SS.GS!Sjj5r\ SS.GS"Sjj5r\ GS#Sj5rS S S.GS$SjjrGS%S S SSSSS.GS&SjjjrGS'SjrGS(SjrGS(SjrGS)SjrGS'SjrGS%GS*SjjrGS+SjrGS+SjrGS+SjrGS+SjrGS+SjrGS,SjrGS,SjrGS,SjrGS,SjrGS,SjrGS,SjrSS.GS-SjjrSSS.GS.Sjjr"SS\&5r%"SS\$\ 5r#GS/Sjr1\b"SS9GS%S S S.GS0Sjjj5r\b"SS9S S S.GS1Sjj5r\b"5GS%S S S.GS2Sjjj5r\b"SS9GS%S S S.GS3Sjjj5r\b"SS9S S S.GS4Sjj5r\b"SS9S S S.GS5Sjj5r\b"SS9S S S.GS4Sjj5r\b"SS9S S S.GS5Sjj5r/SQrg (6) annotationswraps) TYPE_CHECKING)Any)Callable)Iterable)Literal)Sequence)cast)overload)warnN) dependencies) exceptions) selectors)ExprKind DataFrame LazyFrame) get_polars)InvalidIntoExprErrorExpr)Then)When)_from_arrow_impl)_from_dict_impl)_from_numpy_impl)_new_series_impl)_read_csv_impl)_read_parquet_impl)_scan_csv_impl)_scan_parquet_impl) get_level) show_versions)when)SchemaSeries)dtypes)Array)Binary)Boolean) Categorical)Date)Datetime)Decimal)Duration)Enum)Field)Float32)Float64)Int8)Int16)Int32)Int64)Int128)List)Object)String)Struct)Time)UInt8)UInt16)UInt32)UInt64)UInt128)Unknown)_from_native_impl)get_native_namespace) to_py_scalar)IntoDataFrameT) IntoFrameT)Implementation)Version)deprecate_native_namespacefind_stacklevel)generate_temporary_column_name)is_ordered_categorical)maybe_align_index)maybe_convert_dtypes)maybe_get_index)maybe_reset_index)maybe_set_indexvalidate_strict_and_pass_though) ModuleType)Mapping)Self)TypeVar)IntoArrowTable)MultiColSelector)MultiIndexSelector)DType) ConcatMethod)IntoExpr) IntoFrame)IntoLazyFrameT) IntoSeries)NonNestedLiteral)SingleColSelector)SingleIndexSelector)_1DArray)_2DArrayFrameTDataFrame[Any]LazyFrame[Any] DataFrameT)bound LazyFrameTSeriesT Series[Any] IntoSeriesTrg)rqdefaultT)rvc\^\rSrSrSr\SSj5r\SSj5r\SSj5r \SSj5r \SSj5r SU4Sjjr SSU4S jjjr \S S .SS jj5r \SS j5r \SSj5r SS .SU4Sjjjr S U4Sjjr S U4Sjjr S!SjrSrU=r$)"rya2Narwhals DataFrame, backed by a native eager dataframe. !!! warning This class is not meant to be instantiated directly - instead: - If the native object is a eager dataframe from one of the supported backend (e.g. pandas.DataFrame, polars.DataFrame, pyarrow.Table), you can use [`narwhals.from_native`][]: ```py narwhals.from_native(native_dataframe) narwhals.from_native(native_dataframe, eager_only=True) ``` - If the object is a dictionary of column names and generic sequences mapping (e.g. `dict[str, list]`), you can create a DataFrame via [`narwhals.from_dict`][]: ```py narwhals.from_dict( data={"a": [1, 2, 3]}, backend=narwhals.get_native_namespace(another_object), ) ``` c[$Nr)selfs M/var/www/html/env/lib/python3.13/site-packages/narwhals/stable/v1/__init__.py_seriesDataFrame._seriess c[$r{rr|s r~ _lazyframeDataFrame._lazyframercgr{r}items r~ __getitem__DataFrame.__getitem__sWZrcgr{rrs r~rrsrcgr{rrs r~rrsrc">[TU]U5$r{)superr)r}r __class__s r~rrsw"4((rc>[TU]US9$)aRestrict available API methods to lazy-only ones. If `backend` is specified, then a conversion between different backends might be triggered. If a library does not support lazy execution and `backend` is not specified, then this is will only restrict the API to lazy-only operations. This is useful if you want to ensure that you write dataframe-agnostic code which all has the possibility of running entirely lazily. Arguments: backend: Which lazy backend collect to. This will be the underlying backend for the resulting Narwhals LazyFrame. If not specified, and the given library does not support lazy execution, then this will restrict the API to lazy-only operations. `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `DASK`, `DUCKDB` or `POLARS`. - As a string: `"dask"`, `"duckdb"` or `"polars"` - Directly as a module `dask.dataframe`, `duckdb` or `polars`. Returns: A new LazyFrame. )backend)rlazy)r}rrs r~rDataFrame.lazys<w|G|,,r. as_seriescgr{rr}rs r~to_dictDataFrame.to_dictsTWrcgr{rrs r~rrsMPrcgr{rrs r~rrs9[TU]US9$)aConvert DataFrame to a dictionary mapping column name to values. Arguments: as_series: If set to true ``True``, then the values are Narwhals Series, otherwise the values are Any. Returns: A mapping from column name to values / Series. r)rr)r}rrs r~rrsw33rc >[TU]5$)zQGet a mask of all duplicated rows in this DataFrame. Returns: A new Series. )r is_duplicatedr}rs r~rDataFrame.is_duplicateds w$&&rc >[TU]5$)zMGet a mask of all unique rows in this DataFrame. Returns: A new Series. )r is_uniquers r~rDataFrame.is_uniques w ""rcPUR[5R55$)zJPrivate, just used to test the stable API. Returns: A new DataFrame. selectall_l1_normr|s r~rDataFrame._l1_norm {{35>>+,,rr)returnztype[Series[Any]])rztype[LazyFrame[Any]])rz-tuple[SingleIndexSelector, SingleColSelector]rr)rz2str | tuple[MultiIndexSelector, SingleColSelector]rrt)rzSingleIndexSelector | MultiIndexSelector | MultiColSelector | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, MultiColSelector]rr])ra SingleIndexSelector | SingleColSelector | MultiColSelector | MultiIndexSelector | tuple[SingleIndexSelector, SingleColSelector] | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, SingleColSelector] | tuple[MultiIndexSelector, MultiColSelector]rzSeries[Any] | Self | Anyr{)r(ModuleType | Implementation | str | Nonerro)r Literal[True]rzdict[str, Series[Any]])rLiteral[False]rzdict[str, list[Any]])rboolrz-dict[str, Series[Any]] | dict[str, list[Any]])rrtrr])__name__ __module__ __qualname____firstlineno____doc__propertyrrr rrrrrr__static_attributes__ __classcell__rs@r~rrys<6ZZ F   :     ) : ) " )"=A-9- --D47WW PP < < 6<<$( 4  4 6 4 4'#--rrc^\rSrSrSr\S Sj5rS SjrS S U4SjjjrSSjr SSU4Sjjjr SSSjjr S r U=r $)riasNarwhals LazyFrame, backed by a native lazyframe. !!! warning This class is not meant to be instantiated directly - instead use [`narwhals.from_native`][] with a native object that is a lazy dataframe from one of the supported backend (e.g. polars.LazyFrame, dask_expr._collection.DataFrame): ```py narwhals.from_native(native_lazyframe) ``` c[$r{rr|s r~ _dataframeLazyFrame._dataframerrcSSKJn SSKJn SSKJn [ X5(a UR$[ X5(a Sn[U5e[ X5(aURUR55$[ U[5(a!UR5nURU5$[5b2S[[U55;aS[U5S3n[U5e[R "[U55e) Nr BaseFramerr)z.Mixing Series with LazyFrame is not supported.polarszExpected Narwhals object, got: z[. Perhaps you: - Forgot a `nw.from_native` somewhere? - Used `pl.col` instead of `nw.col`?)narwhals.dataframer narwhals.exprrnarwhals.seriesr* isinstance_compliant_frame TypeError_to_compliant_expr__narwhals_namespace__strcolrtyperfrom_invalid_type)r}argrrr*msgplxs r~_extract_compliantLazyFrame._extract_compliant!s 1&* c % %'' ' c " "BCC. c ))$*E*E*GH H c3  --/C773<  < #CS N(B1$s)=77  C. "44T#Y??rc (>[TU]"SSU0UD6$)aMMaterialize this LazyFrame into a DataFrame. As each underlying lazyframe has different arguments to set when materializing the lazyframe into a dataframe, we allow to pass them as kwargs (see examples below for how to generalize the specification). Arguments: backend: specifies which eager backend collect to. This will be the underlying backend for the resulting Narwhals DataFrame. If None, then the following default conversions will be applied: - `polars.LazyFrame` -> `polars.DataFrame` - `dask.DataFrame` -> `pandas.DataFrame` - `duckdb.PyRelation` -> `pyarrow.Table` - `pyspark.DataFrame` -> `pyarrow.Table` `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW` or `POLARS`. - As a string: `"pandas"`, `"pyarrow"` or `"polars"` - Directly as a module `pandas`, `pyarrow` or `polars`. kwargs: backend specific kwargs to pass along. To know more please check the backend specific documentation: - [polars.LazyFrame.collect](https://docs.pola.rs/api/python/dev/reference/lazyframe/api/polars.LazyFrame.collect.html) - [dask.dataframe.DataFrame.compute](https://docs.dask.org/en/stable/generated/dask.dataframe.DataFrame.compute.html) Returns: DataFrame rr)rcollect)r}rkwargsrs r~rLazyFrame.collect=sHw9w9&99rcPUR[5R55$)zJPrivate, just used to test the stable API. Returns: A new lazyframe. rr|s r~rLazyFrame._l1_normcrrc">[TU]U5$)zGet the last `n` rows. Arguments: n: Number of rows to return. Returns: A subset of the LazyFrame of shape (n, n_columns). )rtail)r}nrs r~rLazyFrame.tailksw|ArcRURURRXS95$)zTake every nth row in the DataFrame and return as a new DataFrame. Arguments: n: Gather every *n*-th row. offset: Starting index. Returns: The LazyFrame containing only the selected rows. roffset)_with_compliantr gather_everyr}rrs r~rLazyFrame.gather_everyvs.##  ! ! . . . B  rrrztype[DataFrame[Any]])rrrrr{)rrrrrrnr)rintrr]rrrrrrr])rrrrrrrrrrrrrrrs@r~rrsh @<=A$:9$:$:  $:$:L-     rrc^\rSrSrSr\S Sj5rSU4SjjrSSSSS.SU4SjjjrSSS S .SU4S jjjjr S r U=r $)r*iaNarwhals 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`][]: ```py narwhals.new_series( name=name, values=values, backend=narwhals.get_native_namespace(another_object), ) ``` c[$r{rr|s r~rSeries._dataframerrc >[TU]5$)z[Convert to dataframe. Returns: A DataFrame containing this Series as a single column. )rto_framers r~rSeries.to_frames w!!rFNsortparallelname normalizec >[TU]XX4S9$)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 Returns: A DataFrame with two columns: - The original values as first column - Either count or proportion as second column, depending on normalize parameter. r)r value_counts)r}rrrrrs r~rSeries.value_countss!.w#t$  rT) bin_countinclude_breakpointc\>SSKJn SSKJn Sn[ XdU"5S9 [ TU]UUUS9$)aBin 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. Returns: A new DataFrame containing the counts of values that occur within each passed bin. r)NarwhalsUnstableWarningrPzZ`Series.hist` is being called from the stable API although considered an unstable feature.messagecategory stacklevel)binsrr)narwhals.exceptionsrnarwhals.utilsrQrrhist)r}rrrrrQrrs r~r Series.histsD* @2 #  SGXYw|1  rrr)rrn) rrrrrz str | Nonerrrrnr{)rzlist[float | int] | Noner int | Nonerrrrn) rrrrrrrrrrrrrs@r~r*r*s6"            :*.! !%#' ! &!  ! ! !  ! ! rr*c^\rSrSrSU4SjjrSSSjjrSSSjjrSSSjjrSS.SSjjrS S S .SS jjr SS jr SSS SS .SSjjjr Sr U=r $)ric >[TU]5$r{)r _taxicab_normrs r~r Expr._l1_normsw$&&rc^^TRUU4SjTRR[R55$)zeGet the first `n` rows. Arguments: n: Number of rows to return. Returns: A new expression. cD>TRU5RT5$r{)rheadrrr}s r~Expr.head..//499!TRU5RT5$r{)rrrs r~rExpr.tail..rrrrs``r~r Expr.tailrrc^^^TRUUU4SjTRR[R55$)zTake every nth value in the Series and return as new Series. Arguments: n: Gather every *n*-th row. offset: Starting index. Returns: A new expression. cB>TRU5RTTS9$)Nr)rr)rrrr}s r~r#Expr.gather_every..s //4AAAfAUrrrs```r~rExpr.gather_every s1~~ U NN 9 9(:M:M N  rN)maintain_orderc^UbSn[U[[5S9 TRU4SjTRR [ R55$)aReturn unique values of this expression. Arguments: maintain_order: Keep the same order as the original expression. This is deprecated and will be removed in a future version, but will still be kept around in `narwhals.stable.v1`. Returns: A new expression. zx`maintain_order` has no effect and is only kept around for backwards-compatibility. You can safely remove this argument.rcB>TRU5R5$r{)runiquerr}s r~rExpr.unique..-s//4;;=r)r UserWarningrQrr with_kindrr)r}r!rs` r~r$ Expr.uniquesR  %7  {?P Q~~ = NN $ $X%8%8 9  rF descending nulls_lastch^^^TRUUU4SjTRR55$)zSort this column. Place null values first. Arguments: descending: Sort in descending order. nulls_last: Place null values last instead of first. Returns: A new expression. cB>TRU5RTTS9$)Nr*)rr)rr+r,r}s r~rExpr.sort..<s%//499%*:r)rrwith_uncloseable_window)r}r+r,s```r~r Expr.sort1s-~~  NN 2 2 4   rc~^TRU4SjTRR[R55$)zPFind elements where boolean expression is True. Returns: A new expression. cB>TRU5R5$r{)rarg_truer%s r~rExpr.arg_true..Is//4==?rrr|s`r~r4 Expr.arg_trueBs1 ~~ ? NN 9 9(:M:M N  rfractionwith_replacementseedc^^^^^TRUUUUU4SjTRR[R55$)aSample randomly from this expression. !!! warning `Expr.sample` is deprecated and will be removed in a future version. Hint: instead of `df.select(nw.col('a').sample())`, use `df.select(nw.col('a')).sample()` instead. Note: this will remain available in `narwhals.stable.v1`. See [stable api](../backcompat.md/) for more information. 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. Returns: A new expression. cF>TRU5RTTTTS9$)Nr7)rsample)rr8rr:r}r9s r~rExpr.sample..is*//4;;H7Gd<r)rrr(rr)r}rr8r9r:s`````r~r= Expr.sampleMs:6~~   NN $ $X%8%8 9   rrr) rrr)r! bool | Nonerr])r+rr,rrr]r{) rrr8z float | Noner9rr:rrr])rrrrrr rrr$rr4r=rrrs@r~rrs'      7; ,*/5 "    "&!&              rrc0\rSrSrSr\R rSrg)r(ipa&Ordered mapping of column names to their data type. Arguments: schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None The schema definition given by column names and their associated. *instantiated* Narwhals data type. Accepts a mapping or an iterable of tuples. rN) rrrrrrNV1_versionrrrr~r(r(pszzHrr(cgr{robjs r~ _stableifyrH|GJrcgr{rrFs r~rHrH~rIrcgr{rrFs r~rHrHCFrcgr{rrFs r~rHrHs%(rcgr{rrFs r~rHrHs!$rcP[U[5(a;[URR [ R 5URS9$[U[5(a;[URR [ R 5URS9$[U[5(a;[URR [ R 5URS9$[U[5(a [URUR 5$U$)N)level)r NwDataFramerr _with_versionrNrC_level NwLazyFramerNwSeriesr*_compliant_seriesNwExprrrrrFs r~rHrHs#{##--;;GJJGszzZZ#{##--;;GJJGszzZZ#x  c++99'**ESZZXX#vC**CMM:: Jrc gr{r native_objectkwdss r~ from_nativer\sADrc gr{rrYs r~r\r\rIrc gr{rrYs r~r\r\rIrc gr{rrYs r~r\r\s"r.) eager_only series_onlycgr{rrZstrictr`eager_or_interchange_onlyra allow_seriess r~r\r\7:r)reracgr{rrcs r~r\r\rgr)r`rarfcgr{rrcs r~r\r\!$rcgr{rrcs r~r\r\ r)rerarfcgr{rrcs r~r\r\rjrcgr{rrcs r~r\r\rlr)r`reracgr{rrcs r~r\r\ KNr)r`rerfcgr{rrcs r~r\r\r)r`rerarfcgr{rrcs r~r\r\ 58rcgr{rrcs r~r\r\rlr)rdr`rarfcgr{rrcs r~r\r\$rjr)rdrerarfcgr{rrcs r~r\r\0rjr)rdr`reracgr{rrcs r~r\r\<rtr)rdr`rerfcgr{rrcs r~r\r\Hrrr)rdr`rerarfcgr{rrcs r~r\r\Trjrcgr{rrcs r~r\r\artrcgr{rrZ pass_throughr`rerarfs r~r\r\mrjrcgr{rr}s r~r\r\yrgrcgr{rr}s r~r\r\rjrcgr{rr}s r~r\r\rlrcgr{rr}s r~r\r\rjrcgr{rr}s r~r\r\rlrcgr{rr}s r~r\r\rprcgr{rr}s r~r\r\rrrcgr{rr}s r~r\r\rtrcgr{rr}s r~r\r\rlr)r~r`rarfcgr{rr}s r~r\r\rjr)r~rerarfcgr{rr}s r~r\r\rjr)r~r`reracgr{rr}s r~r\r\rtr)r~r`rerfcgr{rr}s r~r\r\ rrrr~r`rerarfcgr{rr}s r~r\r\rtrF)recgr{rr}s r~r\r\"s r)rdr~r`rerarfc N[U[[45(a U(dU$[U[5(aU(dU(aU$[ XSSS9nU(a#S[ [ U55<3n[U5e[UUUUUU[RS9n [U 5$)a Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series. Arguments: native_object: Raw object from user. Depending on the other arguments, input object can be: - a Dataframe / Lazyframe / Series supported by Narwhals (pandas, Polars, PyArrow, ...) - an object which implements `__narwhals_dataframe__`, `__narwhals_lazyframe__`, or `__narwhals_series__` strict: Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (default): raise an error - `True`: pass object through as-is eager_only: Whether to only allow eager objects: - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. series_only: Whether to only allow Series: - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe): - `False` or `None` (default): don't convert to Narwhals if `native_object` is a Series - `True`: allow `native_object` to be a Series Returns: DataFrame, LazyFrame, Series, or original object, depending on which combination of parameters was passed. Fpass_through_defaultemit_deprecation_warningz1from_native() got an unexpected keyword argument )r~r`rerarfversion) rrrr*rZnextiterrrHrNrCrH) rZrdr~r`rerarfr[rresults r~r\r\.sz-)Y!788-((k\25SXL A$tDzBRAUVn !";! F f r)rdcgr{rnarwhals_objectrds r~ to_nativerrcgr{rrs r~rrrcgr{rrs r~rrrcgr{rrs r~rrs=@rr~cgr{rrr~s r~rrrrcgr{rrs r~rrrrcgr{rrs r~rrrrcgr{rrs r~rrrLr)rdr~cSSKJn SSKJn SSKJn U"XSSS9n[ X5(aURR$[ X5(aURR$U(dS[U5S3n[U5eU$) aConvert Narwhals object to native one. Arguments: narwhals_object: Narwhals object. strict: Determine what happens if `narwhals_object` isn't a Narwhals class: - `True` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). pass_through: Determine what happens if `narwhals_object` isn't a Narwhals class: - `False` (default): raise an error - `True`: pass object through as-is Returns: Object of class that user started with. rrr)rYFrzExpected Narwhals object, got .) rrrr*rrZrr _native_framerVnativerr)rrdr~rr*rZrs r~rrs:-&>25SXL/--//===/**00777 .tO/D.EQGn rTcV^^^^^[UTSSS9mSUUUUU4SjjnUcU$U"U5$)aj Decorate function so it becomes dataframe-agnostic. This will try to convert any dataframe/series-like object into the Narwhals respective DataFrame/Series, while leaving the other parameters as they are. Similarly, if the output of the function is a Narwhals DataFrame or Series, it will be converted back to the original dataframe/series type, while if the output is another type it will be left as is. By setting `pass_through=False`, then every input and every output will be required to be a dataframe/series-like object. Arguments: func: Function to wrap in a `from_native`-`to_native` block. strict: **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (default): raise an error - `True`: pass object through as-is eager_only: Whether to only allow eager objects: - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. series_only: Whether to only allow Series: - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe): - `False` or `None`: don't convert to Narwhals if `native_object` is a Series - `True` (default): allow `native_object` to be a Series Returns: Decorated function. TFrc@>^[T5SUUUUUU4Sjj5nU$)Nc>UVs/sHn[UTT T TT S9PM nnUR5VVs0sHup4U[UTT T TT S9_M nnn/UQUR5Q7Vs1sH n[USS5=n(dMU"5iM" nnUR 5S:a Sn[ U5eT "U0UD6n [ U TS9$s snfs snnfs snf)Nr__native_namespace__z_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r)r\itemsvaluesgetattr__len__ ValueErrorr)argsrrrvaluevbbackendsrrrfr`refuncr~ras r~wrapper.narwhalify..decorator..wrappers%   C!-).G +!-    *$*<<> $2KDk!-).G +!- $2  342&--/22A $:DAAAA2  !A%w o%4*6*FV,? ?I  sCC (C C)rrrrrrr)rrrfr`rer~ras` r~ decoratornarwhalify..decorators) t% @% @ % @Nr)rCallable[..., Any]rrrY)rrdr~r`rerarfrs ````` r~ narwhalifyrs>z3 4RWL))V |rc>[[R"55$)zTInstantiate an expression representing all columns. Returns: A new expression. )rHnwrrrr~rrD bffh rc:[[R"U65$)zCreates an expression that references one or more columns by their name(s). Arguments: names: Name(s) of the columns to use. Returns: A new expression. )rHrrnamess r~rrMs bffen %%rc:[[R"U65$)zCreates an expression that excludes columns by their name(s). Arguments: names: Name(s) of the columns to exclude. Returns: A new expression. )rHrexcluders r~rrYs bjj%( ))rc:[[R"U65$)a)Creates an expression that references one or more columns by their index(es). Notes: `nth` is not supported for Polars version<1.0.0. Please use [`narwhals.col`][] instead. Arguments: indices: One or more indices representing the columns to retrieve. Returns: A new expression. )rHrnth)indicess r~rres bffg& ''rc>[[R"55$)z;Return the number of rows. Returns: A new expression. )rHrlenrrr~rrurrc@[[R"X55$)aReturn an expression representing a literal value. Arguments: value: The value to use as literal. dtype: The data type of the literal value. If not provided, the data type will be inferred by the native library. Returns: A new expression. )rHrlit)rdtypes r~rr~s bffU* ++rc:[[R"U65$)zReturn the minimum value. Note: Syntactic sugar for ``nw.col(columns).min()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Returns: A new expression. )rHrmincolumnss r~rr bffg& ''rc:[[R"U65$)zReturn the maximum value. Note: Syntactic sugar for ``nw.col(columns).max()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Returns: A new expression. )rHrmaxrs r~rrrrc:[[R"U65$)zGet the mean value. Note: Syntactic sugar for ``nw.col(columns).mean()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )rHrmeanrs r~rrs bggw' ((rc:[[R"U65$)aPGet the median value. Notes: - Syntactic sugar for ``nw.col(columns).median()`` - Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )rHrmedianrs r~rrs bii) **rc:[[R"U65$)zSum all values. Note: Syntactic sugar for ``nw.col(columns).sum()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )rHrsumrs r~rrrrc:[[R"U65$)aSum all values horizontally across columns. Warning: Unlike Polars, we support horizontal sum over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrsum_horizontalexprss r~rr b''/ 00rc:[[R"U65$)zCompute the bitwise AND horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrall_horizontalrs r~rr b''/ 00rc:[[R"U65$)zCompute the bitwise OR horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrany_horizontalrs r~rrrrc:[[R"U65$)zCompute the mean of all values horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrmean_horizontalrs r~rrs b((%0 11rc:[[R"U65$)a Get the minimum value horizontally across columns. Notes: We support `min_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrmin_horizontalrs r~rrrrc:[[R"U65$)a Get the maximum value horizontally across columns. Notes: We support `max_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )rHrmax_horizontalrs r~rr rrverticalhowc P[S[[R"XS955$)aConcatenate multiple DataFrames, LazyFrames into a single entity. Arguments: items: DataFrames, LazyFrames to concatenate. how: concatenating strategy: - vertical: Concatenate vertically. Column names must match. - horizontal: Concatenate horizontally. If lengths don't match, then missing rows are filled with null values. This is only supported when all inputs are (eager) DataFrames. - diagonal: Finds a union between the column schemas and fills missing column values with null. Returns: A new DataFrame or LazyFrame resulting from the concatenation. Raises: TypeError: The items to concatenate should either all be eager, or all lazy rmr)r rHrconcat)rrs r~rr0s( *RYYu%>? @@r separator ignore_nullscH[[R"U/UQ7XS.65$)aHorizontally concatenate columns into a single string column. Arguments: exprs: Columns to concatenate into a single string column. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. Non-`String` columns are cast to `String`. *more_exprs: Additional columns to concatenate into a single string column, specified as positional arguments. separator: String that will be used to separate the values of each column. ignore_nulls: Ignore null values (default is `False`). If set to `False`, null values will be propagated and if the row contains any null values, the output is null. Returns: A new expression. r)rHr concat_str)rrr more_exprss r~rrGs',  eYjYIY rc@^\rSrSr\SSj5rSU4SjjrSrU=r$)ribc&U"UR5$r{) _predicate)clsr's r~ from_whenWhen.from_whencs4??##rcH>[R[TU] U55$r{)r from_thenrthenr}rrs r~r When.thengs~~egl5122rr)r'NwWhenrr)r&IntoExpr | NonNestedLiteral | _1DArrayrr) rrrr classmethodrrrrrs@r~rrbs$$33rrc@^\rSrSr\SSj5rSU4SjjrSrU=r$)rikc<U"URUR5$r{)rr)rrs r~rThen.from_thenls4**DNN;;rc4>[[TU] U55$r{)rHr otherwisers r~r Then.otherwiseps%'+E233rr)rNwThenrr)rrrr) rrrrrrr rrrs@r~rrks<<44rrc8[R[U65$)aGStart a `when-then-otherwise` expression. Expression similar to an `if-else` statement in Python. Always initiated by a `pl.when().then()`, and optionally followed by a `.otherwise()` can be appended at the end. If not appended, and the condition is not `True`, `None` will be returned. !!! info Chaining multiple `.when().then()` statements is currently not supported. See [Narwhals#668](https://github.com/narwhals-dev/narwhals/issues/668). Arguments: predicates: Condition(s) that must be met in order to apply the subsequent statement. Accepts one or more boolean expressions, which are implicitly combined with `&`. String input is parsed as a column name. Returns: A "when" object, which `.then` can be called on. )rrnw_when) predicatess r~r'r'ts, >>':. //r)required)rnative_namespacec ^[SU5n[[XX#[RS95$)aInstantiate Narwhals Series from iterable (e.g. list or array). Arguments: name: Name of resulting Series. values: Values of make Series from. 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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Returns: A new Series !ModuleType | Implementation | strrr)r rHr rNrC)rrrrrs r~ new_seriesrs/D6@G uwzzR rc\[SU5n[[X[RS95$)aConstruct a DataFrame from an object which supports the PyCapsule Interface. Arguments: native_frame: Object which implements `__arrow_c_stream__`. 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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Returns: A new DataFrame. rr)r rHrrNrC) native_framerrs r~ from_arrowrs,:6@G  K rc F[[XU[RS95$)a.Instantiate DataFrame from dictionary. Indexes (if present, for pandas-like backends) are aligned following the [left-hand-rule](../pandas_like_concepts/pandas_index.md/). Notes: For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Dictionary to create DataFrame from. schema: The DataFrame schema as Schema or dict of {name: type}. If not specified, the schema will be inferred by the native library. backend: specifies which eager backend instantiate to. Only necessary if inputs are not Narwhals Series. `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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.26.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Returns: A new DataFrame. r)rHrrNrCdataschemarrs r~ from_dictrs"P gwzzJ rc ^[SU5n[[XU[RS95$)a|Construct a DataFrame from a NumPy ndarray. Notes: Only row orientation is currently supported. For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Two-dimensional data represented as a NumPy ndarray. schema: The DataFrame schema as Schema, dict of {name: type}, or a sequence of str. 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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Returns: A new DataFrame. rr)r rHrrNrCrs r~ from_numpyr!s+J6@G &tWgjjY ZZrc H[SU5n[[U4SU0UD65$)a Read a CSV file into a DataFrame. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.27.2): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.read_csv('file.csv', backend='pandas', engine='pyarrow')`. Returns: DataFrame. rr)r rHr!sourcerrrs r~read_csvr%.s1@6@G v9w9&9 rc H[SU5n[[U4SU0UD65$)aLazily read from a CSV file. For the libraries that do not support lazy dataframes, the function reads a csv file eagerly and then converts the resulting dataframe to a lazyframe. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.scan_csv('file.csv', backend=pd, engine='pyarrow')`. Returns: LazyFrame. rr)r rHr#r#s r~scan_csvr'Ts1F6@G v9w9&9 rc H[SU5n[[U4SU0UD65$)aRead into a DataFrame from a parquet file. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `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`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.read_parquet('file.parquet', backend=pd, engine='pyarrow')`. Returns: DataFrame. rr)r rHr"r#s r~ read_parquetr)}s1@6@G 6=7=f= rc H[SU5n[[U4SU0UD65$)a Lazily read from a parquet file. For the libraries that do not support lazy dataframes, the function reads a parquet file eagerly and then converts the resulting dataframe to a lazyframe. !!! note Spark like backends require a session object to be passed in `kwargs`. For instance: ```py import narwhals as nw from sqlframe.duckdb import DuckDBSession nw.scan_parquet(source, backend="sqlframe", session=DuckDBSession()) ``` Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN`, `CUDF`, `PYSPARK` or `SQLFRAME`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"`, `"cudf"`, `"pyspark"` or `"sqlframe"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin`, `cudf`, `pyspark.sql` or `sqlframe`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.31.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.scan_parquet('file.parquet', backend=pd, engine='pyarrow')`. Returns: LazyFrame. rr)r rHr$r#s r~ scan_parquetr+s1b6@G 6=7=f= r)Pr,r-r.r/rr0r1r2r3r4rr5r6r7rMr8r9r:r;r<rr=r>r(r*r?r@rArBrCrDrErFrGrrrrrrrr+rrrrr\r!rRr%rIrSrrrrrTrUrVrWrXrrrrrrrrr%r)r'r+rr&rrrrJr')rGzNwDataFrame[IntoFrameT]rzDataFrame[IntoFrameT])rGzNwLazyFrame[IntoFrameT]rLazyFrame[IntoFrameT])rGzNwSeries[IntoSeriesT]rSeries[IntoSeriesT])rGrWrr)rGrrr)rGzXNwDataFrame[IntoFrameT] | NwLazyFrame[IntoFrameT] | NwSeries[IntoSeriesT] | NwExpr | AnyrzPDataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT] | Expr | Any)rZrsr[rrrs)rZrpr[rrrp)rZrrr[rrrr)rZDataFrameT | LazyFrameTr[rrr.)rZIntoDataFrameT | IntoSeriesTrdrr`rrerrarrfrr/DataFrame[IntoDataFrameT] | Series[IntoSeriesT])rZr/rdrr`rrerrarrfrrr0)rZrKrdrr`rrerrarrfNonerDataFrame[IntoDataFrameT])rZrwrdrr`rrerrarrfr1rrw)rZrKrdrr`rrerrarrfr1rr2)rZrwrdrr`rrerrarrfr1rrw)rZIntoFrameT | IntoSeriesTrdrr`rrerrarrfrrCDataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT])rZrurdrr`rrerrarrfr1rr-)rZrLrdrr`rrerrarrfr1r-DataFrame[IntoFrameT] | LazyFrame[IntoFrameT])rZrwrdrr`rrerrarrfr1rrw)rZrKrdrr`rrerrarrfr1rr2)rZrKrdrr`rrerrarrfr1rr2)rZIntoFrame | IntoSeriesrdrr`rrerrarrfrr-DataFrame[Any] | LazyFrame[Any] | Series[Any])rZrurdrr`rrerrarrfr1rr-)rZrfrdrr`rrerrarrfr1rzLazyFrame[IntoLazyFrameT])rZrLrdrr`rrerrarrfr1rr5)rZzIntoDataFrameT | IntoSeriesr~rr`rrerrarrfrrr2)rZr/r~rr`rrerrarrfrrr0)rZrKr~rr`rrerrarrfr1rr2)rZrwr~rr`rrerrarrfr1rrw)rZrKr~rr`rrerrarrfr1rr2)rZrwr~rr`rrerrarrfr1rrw)rZr3r~rr`rrerrarrfrrr4)rZrur~rr`rrerrarrfr1rr-)rZrLr~rr`rrerrarrfr1rr5)rZrwr~rr`rrerrarrfr1rrw)rZrKr~rr`rrerrarrfr1rr2)rZrKr~rr`rrerrarrfr1rr2)rZr6r~rr`rrerrarrfrrr7)rZrur~rr`rrerrarrfr1rr-)rZrLr~rr`rrerrarrfr1rr5)rZrr~rr`rrerrarrfrArr)rZz5IntoFrameT | IntoFrame | IntoSeriesT | IntoSeries | TrdrAr~rAr`rrerrarrfrAr[rrzGLazyFrame[IntoFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T)rr2rdrrrK)rr,rdrrrL)rr-rdrrru)rrrdrrr)rr2r~rrrK)rr,r~rrrL)rr-r~rrru)rrr~rrr)rzGDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]rdrAr~rArzIntoFrameT | IntoSeriesT | Anyr{)rzCallable[..., Any] | NonerdrAr~rAr`rrerrarrfrArr)rr)rzstr | Iterable[str]rr)rzint | Sequence[int]rr)rrhrDType | type[DType] | Nonerr)rrrr)rIntoExpr | Iterable[IntoExpr]rr)rzIterable[FrameT]rrcrrm) rr9rrdrrrrrr)rr9rr) rrrrrr8rrrModuleType | Nonerrt)rr_rrrr:rrn) rzMapping[str, Any]rz#Mapping[str, DType] | Schema | Nonerrrr:rrn) rrlrz3Mapping[str, DType] | Schema | Sequence[str] | Nonerrrr:rrn) r$rrrrr:rrrrn) r$rrrrr:rrrro) __future__r functoolsrtypingrrrr r r r r warningsrnarwhalsrrrrnarwhals._expression_parsingrrrrQrrTnarwhals.dependenciesrrrrrrWnarwhals.functionsrrrrrrrr r!r"r#r$r%r&r'rnarwhals.schemar(NwSchemarr*rUnarwhals.stable.v1r+narwhals.stable.v1.dtypesr,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGnarwhals.translaterHrIrJnarwhals.typingrKrLrrMrNrOrQrRrSrTrUrVrWrXrZtypesr[r\typing_extensionsr]r^narwhals._translater_r`ranarwhals.dtypesrbrcrdrerfrgrhrirjrkrlrmrprrrsrurwrHr\rrrrrrrrrrrrrrrrrrrrrrrrr!r%r'r)r+__all__rrr~rNs." !177,4(--/.//-1-1(,...%+,-1*.-.*+--*+++,*,,,*+,,,--03+*&)"5*91,/*,*: &)235%,().*013(( X/1A BF-=>J-=>Ji}5G-|SIKS!A-|