Wh2 ddlmZddlmZddlmZmZmZmZm Z m Z ddl Z ddl m Z mZddlmZmZddlmZmZmZmZmZmZmZmZmZmZmZddlm Z!m"Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@dd lAmBZCdd lDmEZEmFZFmGZGdd lHmIZJdd lKmLZMddlNmOZOmPZPmQZQddlRmSZSmTZTmUZUddlVmWZWmXZXerddlYmZZZm[Z[m\Z\ddl]m^Z^m_Z_ddl`maZaddlbmcZcmdZdmeZemfZfmgZgmhZhmiZiddlmjZjmkZkddl$mlZlddlVmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZueddZveddZweddZxede Zye^d!Zzed"Z{ed#d$e%Z|Gd&d'e!eWZ Gd(d)e#eXZ"Gd*d+eMe|ZLGd,d-eCZBGd.d/eJZIe d~d0Z}e dd1Z}e dd2Z}e dd3Z} dd4Z}e dd5Z~e dd6Z~e dd7Z~e dd8Z~e d9d9d: dd;Z~e d9d< dd=Z~e d9d9d9d> dd?Z~e d9d9d9d> dd@Z~e d9d9dA ddBZ~e d9d9dA ddCZ~e d9d9dD ddEZ~e d9d9d9d9dF ddGZ~e d9d9d9d9dF ddHZ~e d9d9d9dI ddJZ~e d9d9d9dK ddLZ~e d9d9d9dM ddNZ~e ddOZ~dPdPdPddF ddQZ~e d9dR ddSZe d9dR ddTZe d9dR ddUZe ddVZdPdR ddWZ ddXdPdPdXdF ddYZddZZdd[Zdd\Zdd]Zdd^Zddd_Zdd`ZddaZddbZddcZdddZddeZddfZddgZddhZddiZddjZdkdPdl ddmZddnZGdodpej(ZGdqdrej*eBZddsZ d ddtZ dduZ dddv ddwZ d ddxZ ddyZ ddzZ dd{Z dd|Zgd}Zy)) annotationswraps) TYPE_CHECKINGAnyCallableLiteralcastoverloadN) exceptions functions)TypeVar assert_never) ImplementationVersiongenerate_temporary_column_name inherit_docis_ordered_categoricalmaybe_align_indexmaybe_convert_dtypesmaybe_get_indexmaybe_reset_indexmaybe_set_indexnot_implemented) DataFrame LazyFrame)ArrayBinaryBoolean CategoricalDateDatetimeDecimalDurationEnumFieldFloat32Float64Int8Int16Int32Int64Int128ListObjectStringStructTimeUInt8UInt16UInt32UInt64UInt128Unknown)Expr)_new_series_implconcat show_versions)Schema)Series) dependenciesdtypes selectors)_from_native_implget_native_namespace to_py_scalar)IntoDataFrameTIntoLazyFrameT)IterableMappingSequence) ParamSpecSelf)IntoArrowTable)ArrowBackend EagerAllowed IntoBackend LazyAllowedPandasPolars)MultiColSelectorMultiIndexSelector)DType) IntoDTypeIntoExpr IntoFrame IntoSeriesNonNestedLiteralSingleColSelectorSingleIndexSelector_1DArray_2DArray DataFrameTDataFrame[Any])bound LazyFrameTLazyFrame[Any]SeriesT Series[Any]T)defaultPR IntoSeriesTrZ)rbrhceZdZejZeedfd Ze dfd Z e ddd dfdZ e d dfd Z e ddZe ddZed d Ze d!d Ze d"d Z d#fd Zd$fd Z ddd d%fdZeddd&dZed'dZedd d(dZdd d(fdZd)fd Zd)fd ZxZS)*rcd|jtjusJt|||yN)level_versionrV2super__init__selfdfro __class__s U/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/stable/v2/__init__.pyrtzDataFrame.__init__g+{{gjj((( 5)c>t|||}td|SNbackendra)rs from_arrowr )cls native_framerresultrxs ryrzDataFrame.from_arrowos'#L'#B$f--r{Nr~c@t||||}td|Sr})rs from_dictr rdataschemarrrxs ryrzDataFrame.from_dictvs)"4"A$f--r{c@t||||}td|Sr}rs from_numpyr rs ryrzDataFrame.from_numpys)#D&'#B$f--r{c"tdtS)Ntype[Series[Any]])r r>rvs ry_serieszDataFrame._seriess'00r{c"tdtS)Ntype[LazyFrame[Any]])r rrs ry _lazyframezDataFrame._lazyframes*I66r{cyNrvitems ry __getitem__zDataFrame.__getitem__sWZr{cyrrrs ryrzDataFrame.__getitem__sr{cyrrrs ryrzDataFrame.__getitem__sr{c"t||Sr)rsr)rvrrxs ryrzDataFrame.__getitem__sw"4((r{c"t||Sr)rs get_column)rvnamerxs ryrzDataFrame.get_columnsw!$''r{)sessionc8tt| ||S)N)rr) _stableifyrslazy)rvrrrxs ryrzDataFrame.lazys %',w,HIIr{. as_seriescyrrrvrs ryto_dictzDataFrame.to_dictsTWr{cyrrrs ryrzDataFrame.to_dictsMPr{Tcyrrrs ryrzDataFrame.to_dicts9)rzIntoBackend[LazyAllowed] | Nonerz Any | Nonerrd)r Literal[True]rzdict[str, Series[Any]])rLiteral[False]rzdict[str, list[Any]])rboolrz-dict[str, Series[Any]] | dict[str, list[Any]])rrf)__name__ __module__ __qualname__rrrrqr NwDataFramert classmethodrrrpropertyrrr rrrrrr __classcell__rxs@ryrrdszzH**.).7P. .. 7;. 59 ..4. 2 .  ..GK..D. + .  ..1177ZZ F   :     ) : ) " )(48J# J0J J  J47WW PP #'< < 6<<$(4 4 643//r{rcbeZdZeedfd ZeddZ d dfd ZxZ S)rcd|jtjusJt|||yrnrprus ryrtzLazyFrame.__init__rzr{ctSrrrs ry _dataframezLazyFrame._dataframer{c 8tt|dd|i|S)Nrr)rrscollect)rvrkwargsrxs ryrzLazyFrame.collects!%'/D'DVDEEr{rrztype[DataFrame[Any]]r)rz+IntoBackend[Polars | Pandas | Arrow] | Nonerrrra) rrrr NwLazyFramertrrrrrs@ryrrs\**FJFBFUXF FFr{rceZdZUejZee d fd Ze d dZ e d dfd Z e d dfd Z dfd Zddddd  dfd ZeZded <xZS)r>rcd|jtjusJt|||yrnrp)rvseriesrorxs ryrtzSeries.__init__s-'**,,, u-r{ctSrrrs ryrzSeries._dataframerr{NcBt|||||}td|SNr~rfrrrvaluesdtyperrrxs ryrzSeries.from_numpys*#D&%#IM6**r{cBt|||||}td|Sr)rs from_iterabler rs ryrzSeries.from_iterables*&tVUG&LM6**r{c2tt| Sr)rrsto_framers ryrzSeries.to_frames%'*,--r{Fsortparallelr normalizec<tt| ||||S)Nr)rrs value_counts)rvrrrrrxs ryrzSeries.value_countss- G H49 !   r{hist)rrrorrrrr) rrrr^rIntoDType | Nonerrrrf) rrrz Iterable[Any]rrrrrrf)rra) rrrrrz str | Nonerrrra)rrrrrrrqrNwSeriesrtrrrrrrrrr__annotations__rrs@ryr>r>s:zzH..%K. .. #' + + + + + +  + + #' + + + + + +  + +.               !D#!r{r>c eZdZy)r9N)rrrrr{ryr9r9'sr{r9cXeZdZejZee d dfd ZxZ S)r=c$t||yr)rsrt)rvrrxs ryrtzSchema.__init__-s  r{r)rz8Mapping[str, DType] | Iterable[tuple[str, DType]] | Nonerr) rrrrrrrqrNwSchemartrrs@ryr=r=*s6zzHQU!N! !!r{r=cyrrobjs ryrr4ORr{cyrrrs ryrr6rr{cyrrrs ryrr8CFr{cyrrrs ryrr:s%(r{cNt|tr>t|jj t j |jSt|tr>t|jj t j |jSt|tr>t|jj t j |jSt|tr t|j|j St#|yrn) isinstancerr_compliant_frame _with_versionrrr_levelrrrr>_compliant_seriesNwExprr9_to_compliant_expr _metadatarrs ryrr>s #{#--;;GJJGszzZZ#{#--;;GJJGszzZZ#x c++99'**ESZZXX#vC**CMM::r{c yrr native_objectkwdss ry from_nativerOsADr{c yrrrs ryrrSGJr{c yrrrs ryrrWrr{c yrrrs ryrr[s"r{.) eager_only series_onlycyrrr pass_throughrr allow_seriess ryrra!$r{)rcyrrrs ryrrls7:r{)rrr cyrrrs ryrrwr r{cyrrrs ryrr r{)rr cyrrrs ryrrr r{cyrrrs ryrrrr{)rr cyrrrs ryrrr{rrrr cyrrrs ryrrr r{cyrrrs ryrrr r{)rrr cyrrrs ryrrr r{)rrrcyrrrs ryrrs58r{)rrr cyrrrs ryrrrr{cyrrrs ryrrs r{Fc t|ttfr|s|St|tr|s|r|S|r"dt t |}t |t|||||tjS)aConvert `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. z1from_native() got an unexpected keyword argument )rrrr version) rrrr>nextiter TypeErrorrBrrr)rrrrr rmsgs ryrrsvZ-)Y!78-(k\ A$tDzBRAUVn !!  r{rcyrrnarwhals_objectrs ry to_nativer$1r{cyrrr"s ryr$r$5r%r{cyrrr"s ryr$r$9sr{cyrrr"s ryr$r$=rr{c0tj||S)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. r )nwr$r"s ryr$r$As& <<l CCr{Tc4dfd }||S||S)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:tdfd }|S)Nc |Dcgc]}t|  }}|jDcic]\}}|t|  }}}g||jDchc]}t|ddx}r|}}|j dkDr d}t | |i|} t | Scc}wcc}}wcc}w)Nr__native_namespace__z_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r )ritemsrgetattr__len__ ValueErrorr$)argsrargrvaluevbbackendsrrr rfuncrrs rywrapperz.narwhalify..decorator..wrappers  !-) +!-  D &$*<<>  D%k!-) +!-  F 342&--/2 $:DAAAAH !A%w o%4*6*FV,? ?E  sB;C'C)r4rrrrrr)r:r;r rrrs` ry decoratorznarwhalify..decorators) t# @# @ # @Jr{)r:Callable[..., Any]rr=r)r:rrrr r<s ```` ry narwhalifyr>Ws&R''R | T?r{c<ttjS)z`Instantiate an expression representing all columns. Returns: A new expression. )rr*allrr{ryr@r@ bffh r{c8ttj|S)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. )rr*colnamess ryrCrCs bffen %%r{c8ttj|S)zCreates an expression that excludes columns by their name(s). Arguments: names: Name(s) of the columns to exclude. Returns: A new expression. )rr*excluderDs ryrGrGs bjj%( ))r{c8ttj|S)aICreates 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. )rr*nth)indicess ryrIrIs bffg& ''r{c<ttjS)zGReturn the number of rows. Returns: A new expression. )rr*lenrr{ryrLrLrAr{c@ttj||S)a!Return 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. )rr*lit)r6rs ryrNrNs bffUE* ++r{c8ttj|S)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. )rr*mincolumnss ryrPrP bffg& ''r{c8ttj|S)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. )rr*maxrQs ryrUrUrSr{c8ttj|S)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. )rr*meanrQs ryrWrWs bggw' ((r{c8ttj|S)atGet 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. )rr*medianrQs ryrYrY$s bii) **r{c8ttj|S)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. )rr*sumrQs ryr[r[5rSr{c8ttj|S)a2Sum 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. )rr*sum_horizontalexprss ryr]r]D b''/ 00r{c>ttj|d|iS)a&Compute 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. Returns: A new expression. ignore_nulls)rr*all_horizontalrbr_s ryrcrcT b''J\J KKr{c>ttj|d|iS)a&Compute 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. Returns: A new expression. rb)rr*any_horizontalrds ryrgrggrer{c8ttj|S)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. )rr*mean_horizontalr^s ryririzs b((%0 11r{c8ttj|S)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. )rr*min_horizontalr^s ryrkrkr`r{c8ttj|S)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. )rr*max_horizontalr^s ryrmrmr`r{ separatorrbcHttj|g|||dS)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. ro)rr* concat_str)r_rprb more_exprss ryrrrrs),  eYjYILY r{c@ttj|g|S)a"Folds 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. Returns: A new expression. )rr*coalesce)r_rss ryrurus bkk%5*5 66r{c2eZdZeddZdfd ZxZS)Whenc&||jSr) _predicate)rwhens ry from_whenzWhen.from_whens4??##r{cHtjt| |Sr)Then from_thenrsthenrvr6rxs ryrz When.thens~~egl5122r{)rzz nw_f.Whenrrw)r6&IntoExpr | NonNestedLiteral | _1DArrayrr})rrrrr{rrrs@ryrwrws$$33r{rwc2eZdZeddZdfd ZxZS)r}c<||j|jSr)rr)rrs ryr~zThen.from_thens4**DNN;;r{c4tt| |Sr)rrs otherwisers ryrzThen.otherwises%'+E233r{)rz nw_f.Thenrr})r6rrr9)rrrrr~rrrs@ryr}r}s<<44r{r}cLtjtj|S)aStart 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. )rwr{nw_frz) predicatess ryrzrzs* >>$))Z0 11r{c2tt||||S)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`. Returns: A new Series r~)rr:)rrrrs ry new_seriesrs4 &tVUGL MMr{cBttj||S)asConstruct 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`. Returns: A new DataFrame. r~)rrr)rrs ryrrs& doolGD EEr{r~cDttj|||S)aInstantiate 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 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`. Returns: A new DataFrame. r~)rrrrrrs ryrr2s@ dnnT67C DDr{cDttj|||S)aUConstruct 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`. Returns: A new DataFrame. r~)rrrrs ryrrUs: doodFGD EEr{c Dttj|fd|i|S)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`. 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. r)rrread_csvsourcerrs ryrrus"* dmmFFGFvF GGr{c Dttj|fd|i|S)asLazily 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`. 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. r)rrscan_csvrs ryrrs"0 dmmFFGFvF GGr{c Dttj|fd|i|S)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')`. Returns: DataFrame. r)rr read_parquetrs ryrrs$* d''JJ6J KKr{c Dttj|fd|i|S)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')`. Returns: LazyFrame. r)rr scan_parquetrs ryrrs%L d''JJ6J KKr{)Rrrrr rr!r"r#r$r%r9r&r'r(rr)r*r+r,r-rr.r/r=r>r0r1r2r3r4r5r6r7r8r@rcrgrurCr;rrr?r@r@r rGrrrrrrCrrLrNrUrmrrrrrrWrirYrPrkr>rrIrrrrrArAr<r[r]r$rDrz)rzNwDataFrame[IntoDataFrameT]rDataFrame[IntoDataFrameT])rzNwLazyFrame[IntoLazyFrameT]rLazyFrame[IntoLazyFrameT])rzNwSeries[IntoSeriesT]rSeries[IntoSeriesT])rrrr9)rzZNwDataFrame[IntoDataFrameT] | NwLazyFrame[IntoLazyFrameT] | NwSeries[IntoSeriesT] | NwExprrzRDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT] | Expr)rrerrrre)rr`rrrr`)rrcrrrrc)rDataFrameT | LazyFrameTrrrr) rzIntoDataFrameT | IntoSeriesrrrrrrr rrr) rzIntoDataFrameT | IntoSeriesTrrrrrrr rrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]) rrErrrrrrr rrr) rrgrrrrrrr rrrg) rrErrrrrrr rrr) rrgrrrrrrr rrrg) rrkrrrrrrr rrr) rrErrrrrrr rrr) rrFrrrrrrr rrr) rrErrrrrrr rrr) rzIntoFrame | IntoSeriesrrrrrrr rrz-DataFrame[Any] | LazyFrame[Any] | Series[Any]) rrkrrrrrrr rrr) rrrrrrrrr  bool | Nonerr)rzJIntoDataFrameT | IntoLazyFrameT | IntoFrame | IntoSeriesT | IntoSeries | Trrrrrrr rrrrzOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T)r#rrrrrE)r#rrrrrF)r#rrrrrk)r#rrrrr)r#zKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]rrrz3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Anyr) r:zCallable[..., Any] | Nonerrrrrrr rrr=)rr9)rEzstr | Iterable[str]rr9)rJzint | Sequence[int]rr9)r6r[rrrr9)rRrrr9)r_IntoExpr | Iterable[IntoExpr]rr9)r_rrbrrr9) r_rrsrXrprrbrrr9)r_rrsrXrr9)rrrrw) rrrrrrrrrrfrrr)rrrrrrrra)rrrzIntoBackend[Backend]rrrrd) __future__r functoolsrtypingrrrr r r narwhalsr*r r rnarwhals._typing_compatrrnarwhals._utilsrrrrrrrrrrrnarwhals.dataframerrrrnarwhals.dtypesrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8 narwhals.exprr9rnarwhals.functionsr:r;r<narwhals.schemar=rnarwhals.seriesr>rnarwhals.stable.v2r?r@rAnarwhals.translaterBrCrDnarwhals.typingrErFcollections.abcrGrHrItyping_extensionsrJrKnarwhals._translaterLnarwhals._typingrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rcrergrirjrkrrr$r>r@rCrGrIrLrNrPrUrWrYr[r]rcrgrirkrmrrrurwr}rzrrrrrrrr__all__rr{ryrs: "HH29    R<)FF..>>TT:;;12H%   -=>J-=>Ji}5GS!A#A Am<E r/ N+r/j F N+ F ;"Xk ";"|6!X! R R R R F F ( (  X " D D J J J J "*"47"" "  "%"% $.$ $ $  $  $$ $ #& :/: : :  :  :5: : "%"% $!$ $ $  $  $$ $ "%"%               #& $!$ $ $  $  $$ $ #&               "%         $'!$"% $!$!$ $  $  $$ $ $'!$"% $!$!$ $  $  $$ $ $'"% $!$!$ $  $  $$ $ $'!$"% 8)8!8 8  8  838 8 $'!$ !              $ $====== =U=@ RU.AO  RU.AO  LO(;I  F F DD  D 9 D.'+U $ U #UU U  U  UUp  & * (   , ( ( )+" ( 1 L&L& 2 1 1&  (   67&349934499d426#N N N N ' N  N:F F.GFF037 E15 E  E / E. E  EJCGF F ?F' F  F@H H6HBEHH0H H1H=@HH6L L6LBELL0&L &L1&L=@&L&LRS r{