Lpjܡ%SSKJr SSKJr SSKJrJrJrJrJ r J r SSK r SSK J r Jr SSKJr SSKJrJr SSKJrJr SS KJrJrJrJrJrJrJrJ r J!r!J"r"J#r# SS K$J%r&J'r( SS K)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrF SS KGJHrH SS KIJJrK SSKLJMrMJNrNJOrO SSKPJQrR SSKSJTrU SSKVJWrWJXrXJYrY SSKZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrb SSKcJdrdJereJfrf \(aqSSKgJhrhJiriJjrjJkrk SSKlJmrmJnrnJoro SSKpJqrqJrrrJsrsJtrtJuruJvrvJwrw SSKxJyryJzrzJ{r{J|r|J}r}J~r~JrJr SSK$JrJr SSKJrJrJrJrJrJrJrJrJr \"S\S9r\m"S5r\"S5r"SS\&\\5r%"S S!\(\^5r'"S"S#\U\`5rT"S$S%\K5rJ"S&S'\R5rQ\ SsS(j5r\ StS)j5r\ SuS*j5r\ SvS+j5rSwS,jr\ SxS-j5r\ SyS.j5r\ SzS/j5r\ S{S0j5r\ S|S1j5r\ S}S2j5r\ S~S3j5r\ SS4j5r\ SS5j5r\ SS6j5r\ SS7j5r\ SS8j5rS9S9S9SS:.SS;jjr\ Sjj5r\ SUR[RLde[TU]XS9 gN)level_versionrV2super__init__selfdfr{ __class__s W/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/stable/v2/__init__.pyrDataFrame.__init__w){{gjj((( )c6>[TU]XS9n[SU5$NbackendDataFrame[Any])r from_arrowr )cls native_framerresultrs rrDataFrame.from_arrows%#L#B$f--rNrc8>[TU]XUS9n[SU5$r)r from_dictr rdataschemarrrs rrDataFrame.from_dicts'"4"A$f--rc8>[TU]XUS9n[SU5$r)r from_dictsr rs rrDataFrame.from_dicts'#D'#B$f--rc8>[TU]XUS9n[SU5$rr from_numpyr rs rrDataFrame.from_numpyrrc"[S[5$)Ntype[Series[Any]])r rCrs r_seriesDataFrame._seriess'00rc"[S[5$)Ntype[LazyFrame[Any]])r rrs r _lazyframeDataFrame._lazyframes*I66rcgNritems r __getitem__DataFrame.__getitem__sWZrcgrrrs rrrsrcgrrrs rrrsrc">[TU]U5$r)rr)rrrs rrrsw"4((rc">[TU]U5$r)r get_column)rnamers rrDataFrame.get_columnsw!$''r)sessionc0>[[TU] XS95$)N)rr) _stableifyrlazy)rrrrs rrDataFrame.lazys %',w,HIIr. as_seriescgrrrrs rto_dictDataFrame.to_dictsTWrcgrrrs rrrsMPrTcgrrrs rrrs9[TU]US9$)Nr)rr)rrrs rrrs w33rc2>[[TU] 55$r)rr is_duplicatedrrs rrDataFrame.is_duplicateds%'/122rc2>[[TU] 55$r)rr is_uniquers rrDataFrame.is_uniques%'+-..rrrrr{&Literal['full', 'lazy', 'interchange']returnNonerr]r&IntoBackend[EagerAllowed | PluginName]rrrrzMapping[str, Any]r2IntoSchema | Mapping[str, IntoDType | None] | Nonerz-IntoBackend[EagerAllowed | PluginName] | Nonerr)rzSequence[Mapping[str, Any]]rrrrrrrrrrz!IntoSchema | Sequence[str] | Nonerrrr)rr)rr)rz-tuple[SingleIndexSelector, SingleColSelector]rr)rz2str | tuple[MultiIndexSelector, SingleColSelector]r Series[Any])rzSingleIndexSelector | MultiIndexSelector | MultiColSelector | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, MultiColSelector]rrW)ra SingleIndexSelector | SingleColSelector | MultiColSelector | MultiIndexSelector | tuple[SingleIndexSelector, SingleColSelector] | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, SingleColSelector] | tuple[MultiIndexSelector, MultiColSelector]rzSeries[Any] | Self | Any)rstrrr)rzIntoBackend[LazyAllowed] | Nonerz Any | NonerLazyFrame[Any])rz Literal[True]rzdict[str, Series[Any]])rLiteral[False]rzdict[str, list[Any]])rboolrz-dict[str, Series[Any]] | dict[str, list[Any]])rr)__name__ __module__ __qualname____firstlineno__rr~r}r NwDataFramer classmethodrrrrpropertyrrr rrrrrr__static_attributes__ __classcell__rs@rrrtsvzzH**.$.8 .  ..FJ. BF ..C. ? .  ...FJ.).C. 8 .  ..59..2. 8 .  ..1177ZZ F   :     ) : ) " )(48J# J0J J  JJ47WW PP #'< < 6<<$(4 4 6443//rrc^\rSrSr\R r\"\5SU4Sjj5r \ SSj5r SS U4Sjjjr Sr U=r$) rc^>UR[RLde[TU]XS9 grzr|rs rrLazyFrame.__init__rrc[$rrrs r _dataframeLazyFrame._dataframerc :>[[TU]"SSU0UD65$)Nrr)rrcollect)rrkwargsrs rrLazyFrame.collects!%'/D'DVDEErrrrztype[DataFrame[Any]]r)rz+IntoBackend[Polars | Pandas | Arrow] | Nonerrrr)rrrrrr~r}r NwLazyFramerrrrrrrs@rrrsezzH**FJFBFUXF FFrrcP^\rSrSr%\R r\"\5SU4Sjj5r \ SSj5r \ SSU4Sjjj5r \ SSU4Sjjj5rSU4SjjrS S SS S .SU4S jjjr\"5rS\S 'S S .SU4SjjjrSrU=r$)rCi rc^>UR[RLde[TU]XS9 grzr|)rseriesr{rs rrSeries.__init__ s+'**,,, -rc[$rrrs rrSeries._dataframerrNc8>[TU]XX4S9n[SU5$Nrrrrrvaluesdtyperrrs rrSeries.from_numpys&#D%#IM6**rc8>[TU]XX4S9n[SU5$r)r from_iterabler rs rrSeries.from_iterable&s&&tU&LM6**rc2>[[TU] 55$r)rrto_framers rrSeries.to_frame2s%'*,--rFsortparallelr normalizec 2>[[TU] XX4S95$)Nr)rr value_counts)rrrrr rs rr Series.value_counts5s) G 4 !   rhist ignore_nullscB>Sn[U[5 [TU] US9$)Nz_`Series.any_value` is being called from the stable API although considered an unstable feature.r)rr=r any_value)rrmsgrs rrSeries.any_valueFs- #  c23w l ;;rr)rrr{rrrrr) rrrrqrIntoDType | Nonerrrr) rrrz Iterable[Any]rrrrrr)rr) rrrrrz str | Noner rrr)rrrrn)rrrrrr~r}rNwSeriesrrrrrrrr rr __annotations__rrrrs@rrCrC sQzzH..%K. .. #' + + + + 8 +  + + #' + + + + 8 +  + +.                !D#!05<<iOFrcvSn[U[5 UR[[R SUS95$)Nz]`Expr.any_value` is being called from the stable API although considered an unstable feature.rr)rr= _append_noderr AGGREGATION)rrrs rrExpr.any_valuePs> #  c23  X));\ R  rcTUR[[RS55$)zGet the first value.firstrrrORDERABLE_AGGREGATIONrs rr Expr.firstZs   (*H*H'!RSSrcTUR[[RS55$)zGet the last value.lastrrs rr" Expr.last^s   (*H*H&!QRRrrN)rrrrW)rrW)rrrrrrr"rrrrr>r>Os05 TSrr>c,\rSrSr\R rSrg)rBicrN)rrrrrr~r}rrrrrBrBcs zzHrrBcgrrobjs rrrgORrcgrrr&s rrrir(rcgrrr&s rrrkCFrcgrrr&s rrrms%(rcH[U[5(a;[URR [ R 5URS9$[U[5(a;[URR [ R 5URS9$[U[5(a;[URR [ R 5URS9$[U[5(a[UR6$[!U5 grz) isinstancerr_compliant_frame _with_versionrr~_levelrrrrC_compliant_seriesNwExprr>_nodesrr&s rrrqs #{##--;;GJJGszzZZ#{##--;;GJJGszzZZ#x  c++99'**ESZZXX#vSZZ  rc grr native_objectkwdss r from_nativer9sPSrc grrr6s rr9r9sQTrc grrr6s rr9r9src grrr6s rr9r9sUXrc grrr6s rr9r9!$rc grrr6s rr9r9rc grrr6s rr9r9r@rc grrr6s rr9r9r>rc grrr6s rr9r9s7:rc grrr6s rr9r9s SVrc grrr6s rr9r9sLOrcgrrr7 pass_through eager_only series_only allow_seriess rr9r9s rFrHrIrJrKc [U[[45(a U(dU$[U[5(aU(dU(aU$[ UUUUUS[ R S9$)a5Convert `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__` pass_through: Determine what happens if the object can't be converted to Narwhals - `False` (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 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. F)rHrIrJrKeager_or_interchange_onlyversion)r.rrrCrOrr~rGs rr9r9s\X-)Y!788-((k\ !!"'  r.rHcgrrnarwhals_objectrHs r to_nativerTrcgrrrRs rrTrTrUrcgrrrRs rrTrTsrcgrrrRs rrTrTr+rc*[R"XS9$)a=Convert Narwhals object to native one. Arguments: narwhals_object: Narwhals object. 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. rP)nwrTrRs rrTrTs& << CCrTc:^^^^SUUUU4SjjnUcU$U"U5$)aDecorate 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. pass_through: Determine what happens if the object can't be converted to Narwhals - `False`: raise an error - `True` (default): 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 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. c>>^[T5SUUUUU4Sjj5nU$)Nc >UVs/sHn[UTT TT S9PM nnUR5VVs0sHupEU[UTT TT S9_M nnn/UQUR5Q7Vs1sH n[USS5=n(dMU"5iM" n nU R 5S:a Sn [ U 5eT"U0UD6n [ U TS9$s snfs snnfs snf)NrL__native_namespace__z_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.rP)r9itemsrgetattr__len__ ValueErrorrT)argsrargargs_nwrvalue kwargs_nwvbbackendsrrrKrIfuncrHrJs rwrapper.narwhalify..decorator..wrapper=s"   C!-) +!-    &$*<<> $2KDk!-) +!- $2  978Y%5%5%788A $:DAAAA8  !A%w o%70i0FV,? ?E  sCC&C  C )rdrrrrrr)rlrmrKrIrHrJs` r decoratornarwhalify..decorator<s) t# @# @ # @Jr)rlCallable[..., Any]rrqr)rlrHrIrJrKros ```` r narwhalifyrrs&R''R | T?rc>[[R"55$)z3Instantiate an expression representing all columns.)rrZallrrrrtrtk 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. )rrZcolnamess rrwrwps bffen %%rc:[[R"U65$)zxCreates an expression that excludes columns by their name(s). Arguments: names: Name(s) of the columns to exclude. )rrZexcluderxs rr{r{ys 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. )rrZnth)indicess rr}r}s bffg& ''rc>[[R"55$)zReturn the number of rows.)rrZlenrrrrrrurc@[[R"X55$)aReturn an expression representing a literal value. Arguments: value: The value to use as literal. Can be a scalar value, list, tuple, or dict. Lists and tuples are converted to `List` dtype, dicts to `Struct` dtype. dtype: The data type of the literal value. If not provided, the data type will be inferred by the native library. For empty lists/dicts, dtype must be specified explicitly. )rrZlit)rgrs rrrs 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. )rrZmincolumnss rrr 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. )rrZmaxrs rrrrrc:[[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 )rrZmeanrs rrrs bggw' ((rc:[[R"U65$)a0Get 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 )rrZmedianrs rrrs 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 )rrZsumrs rrrrrc:[[R"U65$)zSum 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. )rrZsum_horizontalexprss rrr b''/ 00rc@[[R"USU065$)aCompute the bitwise AND horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. ignore_nulls: Whether to ignore nulls: - If `True`, null values are ignored. If there are no elements, the result is `True`. - If `False`, Kleene logic is followed. Note that this is not allowed for pandas with classical NumPy dtypes when null values are present. r)rrZall_horizontalrrs rrr b''J\J KKrc@[[R"USU065$)aCompute the bitwise OR horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. ignore_nulls: Whether to ignore nulls: - If `True`, null values are ignored. If there are no elements, the result is `False`. - If `False`, Kleene logic is followed. Note that this is not allowed for pandas with classical NumPy dtypes when null values are present. r)rrZany_horizontalrs rrrrrc:[[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. )rrZmean_horizontalrs rrr s b((%0 11rc:[[R"U65$)zGet 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. )rrZmin_horizontalrs rrrrrc:[[R"U65$)zGet 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. )rrZmax_horizontalrs rrr#rrc>[[R"XUS95$)zCompute the Pearson's or Spearman rank correlation between two columns. Arguments: a: Column name or Expression b: Column name or Expression method: Correlation method ('pearson' or 'spearman') )method)rrZcorr)arjrs rrr0s bgga62 33rr_ddofc>[[R"XUS95$)aCompute the covariance between two columns. Arguments: a: Column name or Expression b: Column name or Expression ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. r)rrZcov)rrjrs rrr=s bffQ- ..r separatorrcH[[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. r)rrZ concat_str)rrr more_exprss rrrIs'&  eYjYIY rcB[[R"U/UQ765$)zFormat expressions as a string. Arguments: f_string: A string that with placeholders. args: Expression(s) that fill the placeholders. )rrZformat)f_stringrds rrras bii040 11rcB[[R"U/UQ765$)aFolds the columns from left to right, keeping the first non-null value. Arguments: exprs: Columns to coalesce, must be a str, nw.Expr, or nw.Series where strings are parsed as column names and both nw.Expr/nw.Series are passed through as-is. Scalar values must be wrapped in `nw.lit`. *more_exprs: Additional columns to coalesce, specified as positional arguments. Raises: TypeError: If any of the inputs are not a str, nw.Expr, or nw.Series. )rrZcoalesce)rrs rrrks bkk%5*5 66rc2\rSrSr\SSj5rSSjrSrg)Wheni{c$U"URSS9$)Nr)chain) _predicate)rwhens r from_whenWhen.from_when|s4??"--rcf/URQURU4P7n[RU5$r)_chainrThen _from_chain)rrg new_chains rthen When.thens/[[TU] U55$r)rr otherwise)rotherwise_valuers rrThen.otherwises%'+O<==rrrIntoExpr | Iterable[IntoExpr]rr)rzIntoExpr | NonNestedLiteralrr>)rrrrrrrrrs@rrrs4>>rrcN[R[R"U65$)aStart a `when-then-otherwise` expression. Expression similar to an `if-else` statement in Python. Always initiated by a `nw.when().then()`, and optionally followed by chained `.when().then()` calls. An `.otherwise()` can be appended at the end. If not appended, and the condition is not `True`, `None` will be returned. 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_fr)rs rrrs" >>$))Z0 11rc ([[XX#S95$)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`. r)rr?)rrrrs r new_seriesrs. &tUL MMrc<[[R"XS95$)a(Construct 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`. r)rrr)rrs rrrs doolD EErrc>[[R"XUS95$)a7Instantiate DataFrame from dictionary. Indexes (if present, for pandas-like backends) are aligned following the [left-hand-rule](../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, dict of {name: type}, or a iterable of (name, type) tuples. If not specified, the schema will be inferred by the native library. If any `dtype` is `None`, the data type for that column 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`. r)rrrrrrs rrrs@ dnnT7C DDrrrc>[[R"XUS95$)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}, an iterable of (name, type) tuples, 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`. r)rrrrs rrrs6 doodGD EEr,)rc F[[R"U4XS.UD65$)aRead 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`. separator: Single byte character to use as separator in the file. 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')`. rr)rrread_csvsourcerrrs rrrs'.  fMgMfM rc F[[R"U4XS.UD65$)a`Lazily 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`. separator: Single byte character to use as separator in the file. 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')`. r)rrscan_csvrs rrr.s'4  fMgMfM rc F[[R"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`. 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')`. r)rr read_parquetrrrs rrrMs$$ d''JJ6J KKrc F[[R"U4SU0UD65$)aLazily 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`. 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')`. r)rr scan_parquetrs rrrbs%F d''JJ6J KKrc@[[R"U0UD65$)aCollect columns into a struct column. Arguments: *exprs: Column(s) to collect into a struct column, specified as positional arguments. Accepts only expression input. Strings are parsed as column names, other non-expression inputs are not allowed. **named_exprs: Additional columns to collect into the struct column, specified as keyword arguments. The columns will be renamed to the keyword used. )rrstruct)r named_exprss rrrs dkk58K8 99r)Vr r!r"r#rr$r%r&r'r(r>r)r*r+r,rr-r.r/r0r1rr2r3rBrCr4r5r6r7r8r9r:r;r<rtrrrrwr@rrrrDrEr r{rrrrr9rrrPrrrrrrrrrrrrrrrrrrr}rrrrrFrArrrrTrQr)r'zNwDataFrame[IntoDataFrameT]rDataFrame[IntoDataFrameT])r'zNwLazyFrame[IntoLazyFrameT]rLazyFrame[IntoLazyFrameT])r'zNwSeries[IntoSeriesT]rSeries[IntoSeriesT])r'r3rr>)r'zZNwDataFrame[IntoDataFrameT] | NwLazyFrame[IntoLazyFrameT] | NwSeries[IntoSeriesT] | NwExprrzRDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT] | Expr)r7rNr8Unpack[OnlySeries]rrN)r7rNr8Unpack[AllowSeries]rrN)r7rGr8Unpack[ExcludeSeries]rrG)r7rMr8Unpack[AllowLazy]rrM)r7rHr8rrr)r7rLr8rrr)r7rLr8rrr)r7rJr8rrr)r7zIntoDataFrameT | IntoSeriesTr8rrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT])r7z-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTr8zUnpack[AllowAny]rKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT])r7rsr8zUnpack[PassThroughUnknown]rrs) r7rrHrrIrrJrrK bool | Nonerr) r7zJIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | TrHrrIrrJrrKrrzOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T)rSrrHrrrH)rSrrHrrrJ)rSrrHrrrL)rSrrHrrr)rSrrHrrz3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Anyr) rlzCallable[..., Any] | NonerHrrIrrJrrKrrrq)rr>)ryzstr | Iterable[str]rr>)r~zint | Sequence[int]rr>)rgrmrrrr>)rrrr>)rrrr>)rrrrrr>)pearson)rrkrjrkrzLiteral['pearson', 'spearman']rr>)rrkrjrkrintrr>) rrrrkrrrrrr>)rrrdrkrr>)rrrrkrr>r) rrrrrrrrrrrrr) rrrrrrrrrr) rrr!IntoBackend[Backend | PluginName]rrrrrr)rrrrrrrr)rrrrrrrr)rzIntoExpr | Sequence[IntoExpr]rrkrr>) __future__r functoolsrtypingrrrr r r narwhalsrZr r rnarwhals._exceptionsrnarwhals._expression_parsingrrnarwhals._typing_compatrrnarwhals._utilsrrrrrrrrrrrnarwhals.dataframerrrrnarwhals.dtypesr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<narwhals.exceptionsr= narwhals.exprr>r3narwhals.functionsr?r@rAnarwhals.schemarBNwSchemanarwhals.seriesrCrnarwhals.stable.v2rDrErFnarwhals.stable.v2.typingrGrHrIrJrKrLrMrNnarwhals.translaterOrPrQcollections.abcrRrSrTrUtyping_extensionsrVrWrXnarwhals._translaterYrZr[r\r]r^r_narwhals._typingr`rarbrcrdrerfrgrhrinarwhals.typingrjrkrlrmrnrorprqrrrsrurvrr9rTrrrtrwr{r}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr__all__rrrr s"EE2.;9    R>8(FF..>>   UTEE99   H    S!A#A A@/ N+@/FF N+F$C499d>2.#N N N N 4 N  N4F F.TFF*BF E>B E  E > E; E  EF(( E( 15F F -F4 F  FD  4     @  /     >L LCLORLL*#L #L>#LJM#L#LL :W r