[iћUddlmZddlmZddlmZmZmZmZm Z m Z m Z ddl Z ddl mZmZddlmZddlmZmZddlmZmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z'm(Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFdd lGmHZHdd lImJZKddlLmMZMmNZNmOZOddlPmQZRddlSmTZUddlVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbddlcmdZdmeZemfZfervddlgmhZhmiZimjZjddlkmlZlmmZmmnZnddlompZpmqZqmrZrmsZsmtZtmuZumvZvddlwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~ddl%mZmZddlmZddlmZmZmZmZmZmZmZmZmZedeZeldZedZGdd e'e\Z&Gd!d"e)e^Z(Gd#d$eUe`ZTGd%d&eKZJGd'd(eRZQe dod)Ze dpd*Ze dqd+Ze drd,Z dsd-Ze dtd.Ze dud/Ze dvd0Ze dwd1Ze dxd2Ze dyd3Ze dzd4Ze d{d5Ze d|d6Ze d}d7Ze d~d8Ze dd9Zd:d:d:dd; dd<Ze d=d> dd?Ze d=d> dd@Ze d=d> ddAZe ddBZd:d> ddCZ ddDd:d:dDd; ddEZddFZddGZddHZddIZddJZdddKZddLZddMZddNZddOZddPZddQZddRZddSZddTZddUZddVZdWd:dX ddYZddZZdd[ZGd\d]ejPZGd^d_ejReJZdd`Z d ddaZ ddbZ dddc dddZe&j\Zdeedf< d ddgZdhdi ddjZdhdi ddkZ ddlZ ddmZgdnZy)) annotationswraps) TYPE_CHECKINGAnyCallableFinalLiteralcastoverloadN) exceptions functions) issue_warning)ExprKindExprNode)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)NarwhalsUnstableWarning)Expr)_new_series_implconcat show_versions)Schema)Series) dependenciesdtypes selectors) DataFrameTIntoDataFrameT IntoFrameIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesT)_from_native_implget_native_namespace to_py_scalar)IterableMappingSequence) ParamSpecSelfUnpack)AllowAny AllowLazy AllowSeries ExcludeSeriesIntoArrowTable OnlySeriesPassThroughUnknown)ArrowBackend EagerAllowed IntoBackend LazyAllowedPandasPolars)MultiColSelectorMultiIndexSelector)DType) IntoDTypeIntoExpr IntoSchemaNonNestedLiteral PythonLiteralSingleColSelectorSingleIndexSelector_1DArray_2DArrayT)defaultPRceZdZejZeedfd Ze dfd Z e ddd dfdZ e d dfd Z e d dfd Z ed dZed!d Zed"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__selfdfry __class__s l/var/www/html/userprofiledev.eatanceapp.com/venv/lib/python3.12/site-packages/narwhals/stable/v2/__init__.pyr~zDataFrame.__init__v+{{gjj((( 5)c>t|||}td|SNbackendDataFrame[Any])r} from_arrowr )cls native_framerresultrs rrzDataFrame.from_arrow~s'#L'#B$f--rNrc@t||||}td|Sr)r} from_dictr rdataschemarrrs rrzDataFrame.from_dicts)"4"A$f--rc@t||||}td|Sr)r} from_dictsr rs rrzDataFrame.from_dicts)#D&'#B$f--rc@t||||}td|Srr} from_numpyr rs rrzDataFrame.from_numpyrrc"tdtS)Ntype[Series[Any]])r rCrs r_serieszDataFrame._seriess'00rc"tdtS)Ntype[LazyFrame[Any]])r r rs r _lazyframezDataFrame._lazyframes*I66rcyNritems r __getitem__zDataFrame.__getitem__sWZrcyrrrs rrzDataFrame.__getitem__srcyrrrs rrzDataFrame.__getitem__src"t||Sr)r}r)rrrs rrzDataFrame.__getitem__sw"4((rc"t||Sr)r} get_column)rnamers rrzDataFrame.get_columnsw!$''r)sessionc8tt| ||S)N)rr) _stableifyr}lazy)rrrrs rrzDataFrame.lazys %',w,HIIr. as_seriescyrrrrs rto_dictzDataFrame.to_dictsTWrcyrrrs rrzDataFrame.to_dictsMPrTcyrrrs rrzDataFrame.to_dicts9Frc|d}t|t|jttj d|S)Nz]`Expr.any_value` is being called from the stable API although considered an unstable feature.rr)rr= _append_noderr AGGREGATION)rrrs rrzExpr.any_valueJs> #  c23  X));\ R  rcT|jttjdS)zGet the first value.firstrrrORDERABLE_AGGREGATIONrs rrz Expr.firstTs   (*H*H'!RSSrcT|jttjdS)zGet the last value.lastrrs rrz Expr.lastXs   (*H*H&!QRRrN)rrrrV)rrV)rrrrrrrrrr>r>Is05 TSrr>cXeZdZejZee d dfd ZxZ S)rBc$t||yr)r}r~)rrrs rr~zSchema.__init__`s  rr)rz8Mapping[str, DType] | Iterable[tuple[str, DType]] | Nonerr) rrrrr|r{rNwSchemar~rrs@rrBrB]s6zzHQU!N! !!rrBcyrrobjs rrrgORrcyrrr s rrrir rcyrrr s rrrkCFrcyrrr s rrrms%(rc2t|tr>t|jj t j |jSt|tr>t|jj t j |jSt|tr>t|jj t j |jSt|trt|jSt!|yrx) isinstancerr_compliant_frame _with_versionrr|_levelrr rrC_compliant_seriesNwExprr>_nodesrr s rrrqs #{#--;;GJJGszzZZ#{#--;;GJJGszzZZ#x c++99'**ESZZXX#vSZZ  rc yrr native_objectkwdss r from_nativersPSrc yrrrs rrrsQTrc yrrrs rrrsrc yrrrs rrrsUXrc yrrrs rrr!$rc yrrrs rrrrc yrrrs rrrr$rc yrrrs rrrr"rc yrrrs rrrs7:rc yrrrs rrrs SVrc yrrrs rrrsLOrcyrrr pass_through eager_only series_only allow_seriess rrrs rFr,r-r.r/c t|ttfr|s|St|tr|s|r|St |||||dt j S)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. F)r,r-r.r/eager_or_interchange_onlyversion)rrr rCrOrr|r+s rrrsVX-)Y!78-(k\ !!"'  r.r,cyrrnarwhals_objectr,s r to_nativer8rcyrrr6s rr8r8r9rcyrrr6s rr8r8srcyrrr6s rr8r8rrc0tj||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. r4)nwr8r6s rr8r8s& <<l CCrTc4dfd }||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)Nr0__native_namespace__z_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r4)ritemsrgetattr__len__ ValueErrorr8)argsrargrvaluevbbackendsrrr/r-funcr,r.s rwrapperz.narwhalify..decorator..wrapper=s   C!-) +!-    &$*<<> $2KD%k!-) +!- $2  342&--/22A $:DAAAA2  !A%w o%4*6*FV,? ?E  sB;C'C)rHrrrrrr)rNrOr/r-r,r.s` r decoratorznarwhalify..decorator<s) t# @# @ # @Jr)rNCallable[..., Any]rrQr)rNr,r-r.r/rPs ```` r narwhalifyrRs&R''R | T?rc<ttjS)z3Instantiate an expression representing all columns.)rr>allrrrrTrTk bffh rc8ttj|S)zCreates an expression that references one or more columns by their name(s). Arguments: names: Name(s) of the columns to use. )rr>colnamess rrWrWps bffen %%rc8ttj|S)zCreates an expression that excludes columns by their name(s). Arguments: names: Name(s) of the columns to exclude. )rr>excluderXs rr[r[ys bjj%( ))rc8ttj|S)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. )rr>nth)indicess rr]r]s bffg& ''rc<ttjS)zReturn the number of rows.)rr>lenrrrr`r`rUrc@ttj||S)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. )rr>lit)rJrs rrbrbs bffUE* ++rc8ttj|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. )rr>mincolumnss rrdrd bffg& ''rc8ttj|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. )rr>maxres rririrgrc8ttj|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 )rr>meanres rrkrks bggw' ((rc8ttj|S)aLGet 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 )rr>medianres rrmrms bii) **rc8ttj|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 )rr>sumres rrororgrc8ttj|S)a Sum 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. )rr>sum_horizontalexprss rrqrq b''/ 00rc>ttj|d|iS)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)rr>all_horizontalrrss rrvrv b''J\J KKrc>ttj|d|iS)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)rr>any_horizontalrws rrzrzrxrc8ttj|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. )rr>mean_horizontalrrs rr|r| s b((%0 11rc8ttj|S)aGet 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. )rr>min_horizontalrrs rr~r~rtrc8ttj|S)aGet 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. )rr>max_horizontalrrs rrr#rtr separatorrcHttj|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. r)rr> concat_str)rsrr more_exprss rrr0s)&  eYjYILY rc@ttj|g|S)zFormat expressions as a string. Arguments: f_string: A string that with placeholders. args: Expression(s) that fill the placeholders. )rr>format)f_stringrHs rrrHs bii040 11rc@ttj|g|S)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. )rr>coalesce)rsrs rrrRs bkk%5*5 66rc2eZdZeddZdfd ZxZS)Whenc&||jSr) _predicate)rwhens r from_whenzWhen.from_whencs4??##rcHtjt| |Sr)Then from_thenr}thenrrJrs rrz When.thengs~~egl5122r)rz nw_f.Whenrr)rJ&IntoExpr | NonNestedLiteral | _1DArrayrr)rrrrrrrrs@rrrbs$$33rrc2eZdZeddZdfd ZxZS)rc ||jSr)r)rrs rrzThen.from_thenlsDKK  rc4tt| |Sr)rr} otherwisers rrzThen.otherwiseps%'+E233r)rz nw_f.Thenrr)rJrrr>)rrrrrrrrs@rrrks!!44rrcLtjtj|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. )rrnw_fr) predicatess rrrts* >>$))Z0 11rc2tt||||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`. r)rr?)rrrrs r new_seriesrs. &tVUGL MMrcBttj||S)aLConstruct 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 doolGD EErrcDttj|||S)aXInstantiate 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. 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> dnnT67C DDrr rcDttj|||S)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`. r)rrrrs rrrs4 doodFGD EEr,)rc Fttj|f||d|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`. 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 Fttj|f||d|S)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`. 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 rrrs),  fMgMfM rc 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')`. r)rr read_parquetrrrs rrr2s$$ d''JJ6J KKrc 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')`. r)rr scan_parquetrs rrrGs%F d''JJ6J KKr)Tr!r"r#r$rr%r&r'r(r)r>r*r+r,rr-r.r/r0r1r r2r3rBrCr4r5r6r7r8r9r:r;r<rTrvrzrrWr@rrDrErEr r[rrrrrrrrPrr`rbrirrrrrrrkr|rmrdr~rRrr]rrrrrFrFrArorqr8rQr)r zNwDataFrame[IntoDataFrameT]rDataFrame[IntoDataFrameT])r zNwLazyFrame[IntoLazyFrameT]rLazyFrame[IntoLazyFrameT])r zNwSeries[IntoSeriesT]rSeries[IntoSeriesT])r rrr>)r zZNwDataFrame[IntoDataFrameT] | NwLazyFrame[IntoLazyFrameT] | NwSeries[IntoSeriesT] | NwExprrzRDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT] | Expr)rrNrUnpack[OnlySeries]rrN)rrNrUnpack[AllowSeries]rrN)rrGrUnpack[ExcludeSeries]rrG)rrMrUnpack[AllowLazy]rrM)rrHrrrr)rrLrrrr)rrLrrrr)rrJrrrr)rzIntoDataFrameT | IntoSeriesTrrrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT])rz-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTrzUnpack[AllowAny]rKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT])rrrrzUnpack[PassThroughUnknown]rrr) rrr,rr-rr.rr/ bool | Nonerr) rzJIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | Tr,rr-rr.rr/rrzOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T)r7rr,rrrH)r7rr,rrrJ)r7rr,rrrL)r7rr,rrr)r7rr,rrz3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Anyr) rNzCallable[..., Any] | Noner,rr-rr.rr/rrrQ)rr>)rYzstr | Iterable[str]rr>)r^zint | Sequence[int]rr>)rJrlrrrr>)rfrrr>)rsIntoExpr | Iterable[IntoExpr]rr>)rsrrrrr>) rsrrrjrrrrrr>)rrrHrjrr>)rsrrrjrr>)rrrr) rrrrrrrrrrr)rrrz#Mapping[str, DType] | Schema | Nonerrrrr) rrrrrrrrrr) rrrIntoBackend[Backend]rrrrrr)rrrrrrrr)rrrrrrrr) __future__r functoolsrtypingrrrr r r r narwhalsr>r rrnarwhals._exceptionsrnarwhals._expression_parsingrrnarwhals._typing_compatrrnarwhals._utilsrrrrrrrrrrrnarwhals.dataframerrr rnarwhals.dtypesr!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<narwhals.exceptionsr= narwhals.exprr>rnarwhals.functionsr?r@rAnarwhals.schemarBrnarwhals.seriesrCrnarwhals.stable.v2rDrErFnarwhals.stable.v2.typingrGrHrIrJrKrLrMrNnarwhals.translaterOrPrQcollections.abcrRrSrTtyping_extensionsrUrVrWnarwhals._translaterXrYrZr[r\r]r^narwhals._typingr_r`rarbrcrdrerfrgnarwhals.stable.v2.dtypesrhnarwhals.typingrirjrkrlrmrnrorprqrrrtrurrr8rRrTrWr[r]r`rbrdrirkrmrorqrvrzr|r~rrrrrrrrrrrrrrrrr__all__rrrrsR"OOO2.;9    R<8(FF..>>   UT;;99H/    S!A#A A}/ N+}/@ F N+ F CASV6L L6LBELL*#L #L1#L=@#L#LLU r