LpjyD%SSKJr SSKJr SSKJr SSKJr SSKJ r J r J r J r J r JrJrJrJr SSKJr SSKJrJrJr SSKJrJrJrJr SS KJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2 SS K3J4r4J5r5 SS K6J7r7J8r8J9r9 SS K:J;r;Jr> SSK?J@r@ SSKAJBrB \ (aSSKCJDrDJErEJFrFJGrGJHrH SSKIJJrJ SSKKJLrL SSKMJNrN SSKJOrOJPrP SSKQrRSSKSrTSSKUrVSSKWJXrXJYrY SSKZJ[r[J\r\ SSK]J^r^ SSKJ_r_ SSK`Jara SSKJbrbJcrcJdrdJereJfrf SSKgJhrhJiri SSKjJkrkJlrlJmrmJnrnJoroJprpJqrqJrrrJsrtJurvJwrwJxrxJyryJzrzJ{r{J|r| \X"S5r}\ r~S\S '\"S!S"S#9r\"S$S%S#9r\"S&S'S#9r\"S(5rS)rsS\S*'S+ruS\S,'"S-S.\ \5r"S/S0\\5r"S1S2\\5rg)3) annotations)abstractmethod)partial)chain) TYPE_CHECKINGAnyClassVarGenericLiteralNoReturnTypeVarget_argsoverload) issue_warning)_parse_into_expr!check_expressions_preserve_lengthis_scalar_like)ArrowPandas_LazyAllowedImpl_LazyFrameCollectImpl)ImplementationVersion_Implementation_resolve_sample_sizecan_lazyframe_collectcheck_columns_existflatten generate_repris_compliant_dataframeis_compliant_lazyframeis_eager_allowedis_index_selector is_iteratoris_lazy_allowed is_list_ofis_sequence_likeis_sequence_of is_slice_none predicates_contains_list_of_boolqualified_type_namesupports_arrow_c_stream)is_numpy_array_2dis_pyarrow_table)ColumnNotFoundErrorInvalidOperationErrorPerformanceWarning)_from_dict_no_backend_is_into_schema)SchemaSeries to_native)CallableIterableIteratorMappingSequence)BytesIO)Path) ModuleType) Concatenate TypeAliasN) ParamSpecSelf)CompliantDataFrameCompliantLazyFrame)CompliantExprAny) ExprMetadata)IntoArrowTable) EagerAllowed IntoBackend LazyAllowed PluginNamePolars)GroupBy LazyGroupBy)AsofJoinStrategy IntoDataFrame IntoDTypeIntoExpr IntoFrame IntoLazyFrame IntoSchema JoinStrategyMultiColSelectorMultiIndexSelectorPivotAggSingleColSelectorSingleIndexSelectorSizeUnitUniqueKeepStrategy_2DArrayPSrB Incomplete_FrameTrU)bound LazyFrameTrV DataFrameTrRRz_MultiColSelector[Series[Any]]rYz _MultiIndexSelector[Series[Any]]rZcf\rSrSr%S\S'S\S'\"5rS\S'\\S*Sj55r S+S jr S*S jr S,S jr S-S jr S.S jrS/Sjr\S0Sj5r\S1Sj5rS1SjrS2SjrS3Sjr\S4Sj5rS5SjrS5SjrS6SjrS7SjrS7SjrS8SjrS9SjrSSS.S:SjjrSS.S;S jjrSS"jjr S?S#jr!S@S$jr"SAS%jr#SAS&jr$SBS'jr%S(r&g))C BaseFramerr_compliant_frame&Literal['full', 'lazy', 'interchange']_levelrimplementationcgNselfs N/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/dataframe.py _compliantBaseFrame._compliants!$c6URR5$rp)rk__native_namespace__rrs rtryBaseFrame.__native_namespace__s$$99;;rwc6URR5$rp)rk__narwhals_namespace__rrs rtr| BaseFrame.__narwhals_namespace__s$$;;==rwc4URXRS9$)Nlevel) __class__rm)rsdfs rt_with_compliantBaseFrame._with_compliants~~b ~44rwcl^/nUR5n[[URRSS9m[ U4Sj[ U55U4SjUR555nUH@nURU5nURU5 URUR5 MB U$)NF)backend allow_literalc34># UH nT"U5v M g7frprq).0xparses rt 1BaseFrame._flatten_and_extract..s .~!U1XX~sc3V># UHupT"U5RU5v M g7frp)alias)rrexprrs rtrrs' M9L+%U4[  u % %9Ls&)) r|rrru_implementationrritems_to_compliant_exprappend_validate_metadata _metadata) rsexprs named_exprs out_exprsns all_exprsrcers @rt_flatten_and_extractBaseFrame._flatten_and_extracts   ( ( * doo&E&EUZ  .wu~ . M9J9J9L M D((,B   R  # #BLL 1rwc[U[U55(a UR$S[U5<S[U5<3n[ U5e)NzExpected `other` to be a , got: ) isinstancetyperkr+ TypeErrorrsothermsgs rt_extract_compliant_frame"BaseFrame._extract_compliant_framesJ eT$Z ( ()) ))*=d*C)FgNabgNhMklnrwc([XRS9$)N) available)rcolumnsrssubsets rt_check_columns_existBaseFrame._check_columns_exists"6\\BBrwcgrprqrsmetadatas rtrBaseFrame._validate_metadata rwc\[URRR55$rp)r4rkschemarrrs rtrBaseFrame.schemas"d++2288:;;rwcH[URR55$rp)r4rkcollect_schemarrs rtrBaseFrame.collect_schemasd++::<==rwcU"U/UQ70UD6$rprq)rsfunctionargskwargss rtpipeBaseFrame.pipes .t.v..rwc[U[5(aU/OUnURURR US95$)Nr)rstrrrk drop_nullsrs rtrBaseFrame.drop_nullss<'44&&##D$9$9$D$DF$D$STTrwc.URR$rp)rkrrrs rtrBaseFrame.columnss$$,,,rwcUR"U0UD6nUVs/sH%n[U5(aUR5OUPM' nnURURR "U65$s snfrp)rr broadcastrrk with_columns)rsrrcompliant_exprscompliant_exprs rtrBaseFrame.with_columnss33UJkJ #2  #2n--  $ $ & #2  ##D$9$9$F$F$XYY  s,A-c[[U55nU(aG[SU55(a0U(d)URURR "U65$UR"U0UD6nU(a?[SU55(a(URURR"U65$UVs/sH%n[U5(aUR5OUPM' nnURURR"U65$![ a nURU5=n(aXTeeSnAff=fs snf)Nc3B# UHn[U[5v M g7frprrrrs rtr#BaseFrame.select..sE*QjC00*c38# UHn[U5v M g7frp)rrs rtrrs"No>!#4#4os) tuplerallrrk simple_select Exceptionrr aggregaterrselect)rsrr flat_exprseerrorrrs rtrBaseFrame.selects<75>* #E*EEEk ++))77D33ZO;O s"No"NNN''(=(=(G(G(YZ Z #2  #2n--  $ $ & #2  ##D$9$9$@$@/$RSS  55jAA5A&   s'D?,E D?D::D?cVURURRU55$rp)rrkrename)rsmappings rtrBaseFrame.renames$##D$9$9$@$@$IJJrwcVURURRU55$rp)rrkheadrsns rtrBaseFrame.head$##D$9$9$>$>q$ABBrwcVURURRU55$rp)rrktailrs rtrBaseFrame.tailrrwcRURURRX!S95$)Nstrict)rrkdrop)rsrrs rtrBaseFrame.drops'##D$9$9$>$>w$>$VWWrwc ^SSKJnJm [U5nU"[ UU4SjUR 555SS06nUR U5un[USS9 URURRU55$)Nr)all_horizontalcolc3>># UHupT"U5U:Hv M g7frprq)rnamevrs rtr#BaseFrame.filter.. s$WCVSY!^CVs ignore_nullsFfilter) function_name) narwhals.functionsrrrrrrrrrkr)rs predicates constraintsrflat_predicates predicatecompliant_predicaters @rtrBaseFrame.filters ;!*-" ?$W;CTCTCV$W X  "&!:!:9!E )*=XV##D$9$9$@$@AT$UVVrwF descending nulls_lastc[/[U/5QUQ5nURURR"XUS.65$)Nr)rrrksort)rsbyrrmore_bys rtrBaseFrame.sortsH/wt}/w/ 0##  ! ! & &j Y  rwreversecl[U/5nURURRXUS95$)Nrr )rrrktop_k)rskrr  flatten_bys rtrBaseFrame.top_ks;bT] ##  ! ! ' '' ' J  rwcSn[U[5(aU/OUn[U[5(aU/OUn[U[5(aU/OUnURnURU5nX7;aSUSUS3n [ U 5eUS:Xa)UcUcUb Sn [ U 5eUR XSSUS9n OyUcNUbUcSUS 3n [ U 5e[U5[U5:wa S n [ U 5eUR XXEUS9n O(UcUbS US 3n [ U 5eUR XX"US9n URU 5$) N)innerleftfullcrossantisemiz2Only the following join strategies are supported: ; found ''.rz>Can not pass `left_on`, `right_on` or `on` keys for cross join)howleft_onright_onsuffixzGEither (`left_on` and `right_on`) or `on` keys should be specified for .z3`left_on` and `right_on` must have the same length.zBIf `on` is specified, `left_on` and `right_on` should be None for ) rrrkrNotImplementedError ValueErrorjoinlenr) rsronrrrr_supported_joins compliantrresults rtr"BaseFrame.join%sNC((bTb)'3777)W!+Hc!:!:H:)) --e4  &FGWFXXabeaffhiC%c* * '>"h&:bnV o%^^tF$FZ("2_`c_ddef o%7|s8},K o%^^6$F"h&:Z[^Z__`a o%^^$F##F++rwcRURURRXS95$)Nroffset)rrk gather_every)rsrr+s rtr,BaseFrame.gather_everySs,##  ! ! . . . B  rwc Sn X;aSU SUS3n [U 5eUcUbUc Sn [U 5eUbUcUb Sn [U 5eUcUcUcUbUc Sn [U 5eUbUcUb Sn [U 5eUbU=p#UbU=pV[U[5(aU/OUn[U[5(aU/OUn[U[5(a:[U[5(a%[ U5[ U5:wa S n [U 5eUR URRURU5UUUUUU S 95$) N)backwardforwardnearestz-Only the following strategies are supported: rrzCEither (`left_on` and `right_on`) or `on` keys should be specified.z>If `on` is specified, `left_on` and `right_on` should be None.zGCan not specify only `by_left` or `by_right`, you need to specify both.z>If `by` is specified, `by_left` and `by_right` should be None.z3`by_left` and `by_right` must have the same length.)rrby_leftby_rightstrategyr) r r!rrlistr#rrk join_asofr) rsrrrr$r2r3rr4r_supported_strategiesrs rtr6BaseFrame.join_asofXs!C  0ABWAXXabjakkmnC%c* * JW_0@WCS/ ! N!48LRCS/ ! J _!5#(8Z S/ ! N!48LRCS/ ! >!# #G >!# #G)'3777)W!+Hc!:!:H: w % %*Xt*D*D LCM )GCS/ !##  ! ! + +--e4!!! ,   rwc [U[5(aU/OUn[U[5(aU/OUnURURR XX4S95$)Nr$index variable_name value_name)rrrrkunpivot)rsr$r;r<r=s rtr>BaseFrame.unpivots_ C((bTb%eS11u##  ! ! ) )- *   rwcSn[U5e)NzDataFrame.__neq__ and LazyFrame.__neq__ are not implemented, please use expressions instead. Hint: instead of df != 0 you may want to use df.select(nw.all() != 0)r rs rt__neq__BaseFrame.__neq__ + "#&&rwcSn[U5e)NzDataFrame.__eq__ and LazyFrame.__eq__ are not implemented, please use expressions instead. Hint: instead of df == 0 you may want to use df.select(nw.all() == 0)rArs rt__eq__BaseFrame.__eq__rDrwc[U[5(aU/UQO/UQUQnURURR US95$)Nr)rrrrkexplode)rsr more_columns to_explodes rtrJBaseFrame.explodesW'3'' $| $*7*\*  ##D$9$9$A$A*$A$UVVrwrqN)returnr)rNr@)rrrNrD)rIntoExpr | Iterable[IntoExpr]rrTrNzlist[CompliantExprAny])rz Self | AnyrNr)rz Sequence[str]rNzColumnNotFoundError | NonerrHrNNonerNr4rz"Callable[Concatenate[Self, PS], R]rzPS.argsrz PS.kwargsrNrgrstr | list[str] | NonerNrDrNz list[str]rrOrrTrNrDrzdict[str, str]rNrDrintrNrD)rz Iterable[str]rboolrNrDrrOrrrNrD rstr | Iterable[str]rrrbool | Sequence[bool]rr[rNrDrrZrr^r r_rNrD)rrbr$rUrrXrrUrrUrrrNrDrrrZr+rZrNrD)rrbr str | Nonerrcr$rcr2rUr3rUrrUr4rQrrrNrD r$rUr;rUr<rr=rrNrD)robjectrNr rstr | Sequence[str]rKrrNrD)'__name__ __module__ __qualname____firstlineno____annotations__rrnpropertyrruryr|rrrrrrrrrrrrrrrrrrrr"r,r6r>rBrFrJ__static_attributes__rqrwrtririrs 22&5&7NO7($$<>53DL ( C  <<>/4// / /U-- Z3 ZDL Z  ZT3TDLT T4KCCX W8 WIL W  W$-2      *      TY  0 ;P  ,,,, #,, ,, ( ,,),,,, ,,\ < <  <  <  < (< )<  #< #< <  < | " &        " ' 'Wrwric ^\rSrSr%Sr\R rS\S'\ SoSj5r \ SpSj5r \ SqSj5r SrSjr SsS jr\StS j5r\SuS S .SvS jjj5r\SuSwSjj5r\SuSxSjj5rSySjrSzS{SjjrS|SjrSuS}SjjrSuS S.S~SjjjrSSjrSSjrSSjr\SuSSjj5r\SSj5rSuSSjjrSSjrSSjr\ SSj5r SSjr!SSS jjr"\SS!j5r#\SS"j5r#\SS#j5r#SS$jr#SS%jr$\S&S'.SS(jj5r%\SS)j5r%\S*S'.SS+jj5r%S*S'.SS,jjr%SS-jr&SU4S.jjr'SuSU4S/jjjr(SS S0.SS1jjjr)\ SU4S2jj5r*SU4S3jjr+\ SU4S4jj5r,\S5S6.SS7jj5r-\SS8j5r-\SS9j5r-S5S6.SS:jjr-SS;jr.\S&S&S<.SS=jj5r/\S&S>.SS?jj5r/\S&S>.SS@jj5r/S5SAS<.SSBjjr/SU4SCjjr0SU4SDjjr1SU4SEjjr2SSU4SFjjjr3SSU4SGjjjr4S*SH.SU4SIjjjr5SuSJS5S SK.SSLjjjr6SU4SMjjr7\S&SN.SSOjj5r8\SSPj5r8S5SN.SSQjjr8S5S5SR.SU4SSjjjr9S5ST.SU4SUjjjr:SS S SVSW.SU4SXjjjjr;S S S S S S SYSVSZ.SU4S[jjjrSS^jr?SS_jr@SzSS`jjrASSajrBSSU4SbjjjrCS S S S S5ScSd.SSejjrDSSfjrESuS S5S Sg.SShjjjrFSuS SiSjSk.SU4SljjjjrGSU4SmjjrHSnrIU=rJ$) DataFrameia/Narwhals 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), ) ``` ClassVar[Version]_versioncUR$rprkrrs rtruDataFrame._compliant$$$rwc[$rpr5rrs rt_seriesDataFrame._seriess rwc[$rp) LazyFramerrs rt _lazyframeDataFrame._lazyframerwcgrprqrs rtrDataFrame._validate_metadatarrwcX lU [U5(aUR5UlgS[ U53n[ U5e)NzCExpected an object which implements `__narwhals_dataframe__`, got: )rmr __narwhals_dataframe__rkrAssertionErrorrsrrrs rt__init__DataFrame.__init__sE>C  !" % %$&$=$=$?D !WX\]_X`WabC % %rwc[U5(d*[U5(dS[U5S3n[U5e[R "U5n[ U5(aOURRR U5RnURRXS9nU"USS9$USUS3n[U5e)uConstruct 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`. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pd.DataFrame({"a": [1, 2], "b": [4.2, 5.1]}) >>> nw.DataFrame.from_arrow(df_native, backend="polars") ┌──────────────────┐ |Narwhals DataFrame| |------------------| | shape: (2, 2) | | ┌─────┬─────┐ | | │ a ┆ b │ | | │ --- ┆ --- │ | | │ i64 ┆ f64 │ | | ╞═════╪═════╡ | | │ 1 ┆ 4.2 │ | | │ 2 ┆ 5.1 │ | | └─────┴─────┘ | └──────────────────┘ zGiven object of type z% does not support PyCapsule interface)contextrrz support in Narwhals is lazy-only, but `DataFrame.from_arrow` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.DataFrame.from_arrow(df, backend='pyarrow').lazy('')) r,r.rrr from_backendr"rr namespacer& _dataframe from_arrowr!)cls native_framerrrnrr&s rtrDataFrame.from_arrowsR( 559I,9W9W)$|*<)==bcCC. '44W= N + +''44^DNNB 000JIy/ /HHVGWWY [ orwNrcTUc [U5upUb [U5OSn[R"U5n[ U5(aPUR R RU5RnURRXUS9nU"USS9$USUS3n[U5e)uInstantiate 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`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> data = {"c": [5, 2], "d": [1, 4]} >>> nw.DataFrame.from_dict(data, backend="pandas") ┌──────────────────┐ |Narwhals DataFrame| |------------------| | c d | | 0 5 1 | | 1 2 4 | └──────────────────┘ Nrrrrz support in Narwhals is lazy-only, but `DataFrame.from_dict` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.DataFrame.from_dict({'a': [1, 2]}, backend='pyarrow').lazy('r) r2dictrrr"rrrr&r from_dictr!rdatarrrnrr&rs rtrDataFrame.from_dict3s^ ?1$7MD!'!3f'44W= N + +''44^DNNB //R/PIy/ /TTbScce g orwc4Ub [U5OSn[R"U5n[U5(aPURR RU5R nURRXUS9nU"USS9$USUS3n[U5e)u Instantiate DataFrame from a sequence of dictionaries representing rows. Notes: Keys missing from some (or all) rows are filled with null. For pandas-like dataframes, conversion to schema is applied after dataframe creation. A `schema` requesting a dtype which cannot hold null values (e.g. `Int64` or `Boolean` with the default numpy dtypes) will therefore coerce or raise on those missing values. Arguments: data: Sequence with dictionaries mapping column name to value. 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. `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`. Tip: If you expect non-uniform keys in `data`, consider passing `schema` for more consistent results, as **inference varies between backends**: - pandas uses all rows - polars uses the first 100 rows - pyarrow uses only the first row Examples: >>> import polars as pl >>> import narwhals as nw >>> data = [ ... {"item": "apple", "weight": 80, "price": 0.60}, ... {"item": "egg", "weight": 55, "price": 0.40}, ... ] >>> nw.DataFrame.from_dicts(data, backend="polars") ┌──────────────────────────┐ | Narwhals DataFrame | |--------------------------| |shape: (2, 3) | |┌───────┬────────┬───────┐| |│ item ┆ weight ┆ price │| |│ --- ┆ --- ┆ --- │| |│ str ┆ i64 ┆ f64 │| |╞═══════╪════════╪═══════╡| |│ apple ┆ 80 ┆ 0.6 │| |│ egg ┆ 55 ┆ 0.4 │| |└───────┴────────┴───────┘| └──────────────────────────┘ Nrrrz support in Narwhals is lazy-only, but `DataFrame.from_dicts` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.DataFrame.from_dicts([{'a': 1}, {'a': 2}], backend='pyarrow').lazy('r) rrrr"rrrr&r from_dictsr!rs rtrDataFrame.from_dictsrs@"(!3f'44W= N + +''44^DNNB 00b0QIy/ /^^l]mmo q orwc[U5(d Sn[U5e[U5(dS[U5S3n[ U5eUb [ U[ 5(d [U5n[R"U5n[U5(aEURRRU5RnU"URX5SS9$USUS3n[U5e)uConstruct 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`. Examples: >>> import numpy as np >>> import polars as pl >>> import narwhals as nw >>> >>> arr = np.array([[5, 2, 1], [1, 4, 3]]) >>> schema = {"c": nw.Int16(), "d": nw.Float32(), "e": nw.Int8()} >>> nw.DataFrame.from_numpy(arr, schema=schema, backend="polars") ┌───────────────────┐ |Narwhals DataFrame | |-------------------| |shape: (2, 3) | |┌─────┬─────┬─────┐| |│ c ┆ d ┆ e │| |│ --- ┆ --- ┆ --- │| |│ i16 ┆ f32 ┆ i8 │| |╞═════╪═════╪═════╡| |│ 5 ┆ 2.0 ┆ 1 │| |│ 1 ┆ 4.0 ┆ 3 │| |└─────┴─────┴─────┘| └───────────────────┘ z)`from_numpy` only accepts 2D numpy arraysz`schema` is expected to be one of the following types: Schema | Mapping[str, IntoDType] | Iterable[tuple[str, IntoDType]] | Sequence[str]. Got rrrz support in Narwhals is lazy-only, but `DataFrame.from_numpy` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.DataFrame.from_numpy(arr, backend='pyarrow').lazy('r)r-r!r3rrr(rr4rrr"rrrr& from_numpy)rrrrrrnrs rtrDataFrame.from_numpysf!&&=CS/ !v&&F|nA'  C. ."="=F^F'44W= N + +''44^DNNBr}}T2&A AIIWHXXZ \ orwc6URR5$rp)rk__len__rrs rtrDataFrame.__len__ s$$,,..rwc4URRXS9$)Ncopy)rk __array__)rsdtypers rtrDataFrame.__array__ s$$..u.@@rwcR[SUR5R55$)NzNarwhals DataFramerr8__repr__rrs rtrDataFrame.__repr__ 14>>3C3L3L3NOOrwcURRn[U5(aURUS9$[R R 5nUS:aS[U53n[U5SeUR5nURUS9$![anS[U53n[U5UeSnAff=f)a@Export a DataFrame via the Arrow PyCapsule Interface. - if the underlying dataframe implements the interface, it'll return that - else, it'll call `to_arrow` and then defer to PyArrow's implementation See [PyCapsule Interface](https://arrow.apache.org/docs/dev/format/CDataInterface/PyCapsuleInterface.html) for more. )requested_schemazT'pyarrow>=14.0.0' is required for `DataFrame.__arrow_c_stream__` for object of type N)r) rk _native_framer,__arrow_c_stream__rPYARROW_backend_versionModuleNotFoundErrorrto_arrow)rsrr pa_versionexcrpa_tables rtrDataFrame.__arrow_c_stream__s,,:: "< 0 022DT2U U 4'//@@BJ  himnzi{h|}C%c* 4==?**` with `BACKEND` being `DASK`, `DUCKDB`, `IBIS` or `POLARS`. - As a string: `"dask"`, `"duckdb"`, `"ibis"` or `"polars"` - Directly as a module `dask.dataframe`, `duckdb`, `ibis` or `polars`. session: Session to be used if backend is spark-like. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2], "b": [4, 6]}) >>> df = nw.from_native(df_native) If we call `df.lazy`, we get a `narwhals.LazyFrame` backed by a Polars LazyFrame. >>> df.lazy() # doctest: +SKIP ┌─────────────────────────────┐ | Narwhals LazyFrame | |-----------------------------| || └─────────────────────────────┘ We can also pass DuckDB as the backend, and then we'll get a `narwhals.LazyFrame` backed by a `duckdb.DuckDBPyRelation`. >>> df.lazy(backend=nw.Implementation.DUCKDB) ┌──────────────────┐ |Narwhals LazyFrame| |------------------| |┌───────┬───────┐ | |│ a │ b │ | |│ int64 │ int64 │ | |├───────┼───────┤ | |│ 1 │ 4 │ | |│ 2 │ 6 │ | |└───────┴───────┘ | └──────────────────┘ Nrlazyrz(Not-supported backend. Expected one of z or `None`, got ) rkrr|rrr%rrr!)rsrrr lazy_backendrs rtrDataFrame.lazy*sT$$)) ???4g#>f?M M%227; < ( (??4 #Ff?U U:8DT;U:VVfgsftuorwc.URR$)aConvert Narwhals DataFrame to native one. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0], "ham": ["a", "b", "c"]} ... ) Calling `to_native` on a Narwhals DataFrame returns the native object: >>> nw.from_native(df_native).to_native() foo bar ham 0 1 6.0 a 1 2 7.0 b 2 3 8.0 c )rkrrrs rtr8DataFrame.to_native}s$$$222rwc6URR5$)a|Convert this DataFrame to a pandas DataFrame. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame( ... {"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0], "ham": ["a", "b", "c"]} ... ) >>> df = nw.from_native(df_native) >>> df.to_pandas() foo bar ham 0 1 6.0 a 1 2 7.0 b 2 3 8.0 c )rk to_pandasrrs rtrDataFrame.to_pandass $$..00rwc6URR5$)uConvert this DataFrame to a polars DataFrame. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> df = nw.from_native(df_native) >>> df.to_polars() shape: (2, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 1 ┆ 6.0 │ │ 2 ┆ 7.0 │ └─────┴─────┘ )rk to_polarsrrs rtrDataFrame.to_polarss&$$..00rwcgrprqrsfiles rt write_csvDataFrame.write_csvs36rwcgrprqrs rtrrs=@rwc8URRU5$)a}Write dataframe to comma-separated values (CSV) file. Arguments: file: String, path object or file-like object to which the dataframe will be written. If None, the resulting csv format is returned as a string. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [1, 2, 3], "bar": [6.0, 7.0, 8.0], "ham": ["a", "b", "c"]} ... ) >>> df = nw.from_native(df_native) >>> df.write_csv() # doctest: +SKIP 'foo,bar,ham\n1,6.0,a\n2,7.0,b\n3,8.0,c\n' If we had passed a file name to `write_csv`, it would have been written to that file. )rkrrs rtrrs($$..t44rwc:URRU5 g)avWrite dataframe to parquet file. Arguments: file: String, path object or file-like object to which the dataframe will be written. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> df = nw.from_native(df_native) >>> df.write_parquet("out.parquet") # doctest:+SKIP N)rk write_parquetrs rtrDataFrame.write_parquets ++D1rwc6URRSSS9$)a!Convert this DataFrame to a NumPy ndarray. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2], "bar": [6.5, 7.0]}) >>> df = nw.from_native(df_native) >>> df.to_numpy() array([[1. , 6.5], [2. , 7. ]]) Nr)rkto_numpyrrs rtrDataFrame.to_numpys $$--d->>rwc.URR$)zGet the shape of the DataFrame. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2]}) >>> df = nw.from_native(df_native) >>> df.shape (2, 1) )rkshaperrs rtrDataFrame.shapes$$***rwchURURRU5URS9$)aGet a single column by name. Arguments: name: The column name as a string. Notes: Although `name` is typed as `str`, pandas does allow non-string column names, and they will work when passed to this function if the `narwhals.DataFrame` is backed by a pandas dataframe with non-string columns. This function can only be used to extract a column by name, so there is no risk of ambiguity. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2]}) >>> df = nw.from_native(df_native) >>> df.get_column("a").to_native() 0 1 1 2 Name: a, dtype: int64 r)rxrk get_columnrm)rsrs rtrDataFrame.get_columns,.||D11<>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> df = nw.from_native(df_native) >>> df.estimated_size() 32 )unit)rkestimated_size)rsrs rtrDataFrame.estimated_sizes"$$333>>rwcgrprqrsitems rt __getitem__DataFrame.__getitem__.sWZrwcgrprqrs rtrr1srwcgrprqrs rtrr6srwcrSSKJn S[U5S3n[U[5(ao[ U5S:a Sn[ U5eU(a[US5(aSOUSn[ U5S:d[US5(aSOUSnUcUcU$OP[U5(aUnSnO;[U5(d[U[[45(aSnUnO [ U5e[U[5(a [ U5eURn[U[5(a [ U5e[U[[45(af[U[5(aURXV5$[U[5(aUOUR UnUR#U5n UbX$U $[XR5(a UR$n[Xb5(a UR$nUcUR'USS2U45$UcUR'XuSS245$UR'XuU45$) aExtract column or slice of DataFrame. Arguments: item: How to slice dataframe. What happens depends on what is passed. It's easiest to explain by example. Suppose we have a Dataframe `df` - `df['a']` extracts column `'a'` and returns a `Series`. - `df[0:2]` extracts the first two rows and returns a `DataFrame`. - `df[0:2, 'a']` extracts the first two rows from column `'a'` and returns a `Series`. - `df[0:2, 0]` extracts the first two rows from the first column and returns a `Series`. - `df[[0, 1], [0, 1, 2]]` extracts the first two rows and the first three columns and returns a `DataFrame` - `df[:, [0, 1, 2]]` extracts all rows from the first three columns and returns a `DataFrame`. - `df[:, ['a', 'c']]` extracts all rows and columns `'a'` and `'c'` and returns a `DataFrame`. - `df[:, [True, False, True]]` extracts all rows and columns in positions 0 and 2 and returns a `DataFrame`. - `df[['a', 'c']]` extracts all rows and columns `'a'` and `'c'` and returns a `DataFrame`. - `df[0: 2, ['a', 'c']]` extracts the first two rows and columns `'a'` and `'c'` and returns a `DataFrame` - `df[:, 0: 2]` extracts all rows from the first two columns and returns a `DataFrame` - `df[:, 'a': 'c']` extracts all rows and all columns positioned between `'a'` and `'c'` _inclusive_ and returns a `DataFrame`. For example, if the columns are `'a', 'd', 'c', 'b'`, then that would extract columns `'a'`, `'d'`, and `'c'`. Notes: - Integers are always interpreted as positions - Strings are always interpreted as column names. In contrast with Polars, pandas allows non-string column names. If you don't know whether the column name you're trying to extract is definitely a string (e.g. `df[df.columns[0]]`) then you should use `DataFrame.get_column` instead. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2]}) >>> df = nw.from_native(df_native) >>> df["a"].to_native() 0 1 1 2 Name: a, dtype: int64 rr5z2Unexpected type for `DataFrame.__getitem__`, got: z. Hints: - use `df.item` to select a single item. - Use `df[indices, :]` to select rows positionally. - Use `df.filter(mask)` to filter rows based on a boolean mask.zzTuples cannot be passed to DataFrame.__getitem__ directly. Hint: instead of `df[indices]`, did you mean `df[indices, :]`?N)narwhals.seriesr6rrrr#rr)r#r'slicerrkr[rZrrr_compliant_seriesr) rsrr6r tuple_msgrowsrr&col_nameseriess rtrrAsz +Ad MN N  dE " "4y1}U **#}T!W'='=447D!$i!m}T!W/E/Ed4PQ7G| t $ $DG d # #z$ 'E'EDGC. dC C. )) gt $ $C. gSz * *$$$yy//",Wc":":w W@UH__X.F#'#36< ? ? d # #))D g & &//G <'' !W*(=> > ?'' '(:; ;##IGm$<==rwcXR;$rprI)rskeys rt __contains__DataFrame.__contains__sll""rw. as_seriescgrprqrsrs rtto_dictDataFrame.to_dictTWrwcgrprqrs rtrrsMPrwTcgrprqrs rtrrs9>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"A": [1, 2], "fruits": ["banana", "apple"]}) >>> df = nw.from_native(df_native) >>> df.to_dict(as_series=False) {'A': [1, 2], 'fruits': ['banana', 'apple']} rr)rkrrrxrm)rsrrvalues rtrrs" #'"7"7"?"?'#@#%'##JC\\%{{\;;#  $$,,y,AA s%A4c8URRU5$)aGet values at given row. Warning: You should NEVER use this method to iterate over a DataFrame; if you require row-iteration you should strongly prefer use of iter_rows() instead. Arguments: index: Row number. Notes: cuDF doesn't support this method. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"a": [1, 2], "b": [4, 5]}) >>> nw.from_native(df_native).row(1) (2, 5) )rkrow)rsr;s rtr DataFrame.rows*$$((//rwc,>[TU]"U/UQ70UD6$)aPipe function call. Arguments: function: Function to apply. args: Positional arguments to pass to function. kwargs: Keyword arguments to pass to function. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "ba": [4, 5]}) >>> nw.from_native(df_native).pipe( ... lambda _df: _df.select( ... [x for x in _df.columns if len(x) == 1] ... ).to_native() ... ) a 0 1 1 2 superrrsrrrrs rtrDataFrame.pipes4w|H6t6v66rwc>[TU]US9$)aPDrop rows that contain null values. Arguments: subset: Column name(s) for which null values are considered. If set to None (default), use all columns. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"a": [1.0, None], "ba": [1.0, 2.0]}) >>> nw.from_native(df_native).drop_nulls().to_native() pyarrow.Table a: double ba: double ---- a: [[1]] ba: [[1]] rrrrsrrs rtrDataFrame.drop_nulls s0w!!00rworder_byc[U[5(aU/OUnURURR XS95$)aInsert column which enumerates rows. Arguments: name: The name of the column as a string. The default is "index". order_by: Column(s) to order by when computing the row index. Nulls are placed first. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"a": [1, 2], "b": [4, 5]}) >>> nw.from_native(df_native).with_row_index().to_native() pyarrow.Table index: int64 a: int64 b: int64 ---- index: [[0,1]] a: [[1,2]] b: [[4,5]] r rrrrkwith_row_indexrsrr  order_by_s rtrDataFrame.with_row_index&sC.#-Xs";";XJ ##  ! ! 0 0 0 J  rwc>[TU]$)aGet an ordered mapping of column names to their data type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> nw.from_native(df_native).schema Schema({'foo': Int64, 'bar': Float64}) )rrrsrs rtrDataFrame.schemaBsw~rwc >[TU]5$)a Get an ordered mapping of column names to their data type. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> nw.from_native(df_native).collect_schema() Schema({'foo': Int64, 'bar': Float64}) rrrs rtrDataFrame.collect_schemaOw%''rwc>[TU]$)aGet column names. Note: The pandas-like and dask backends allow non-string column names (e.g. integers or booleans). While discouraged, this is supported, so the return type is not guaranteed to be `list[str]`. See [concepts - column names](../concepts/column_names.md) for details. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> nw.from_native(df_native).columns ['foo', 'bar'] rrrs rtrDataFrame.columns[$wrwFnamedcgrprqrsrs rtrDataFrame.rowsosORrwcgrprqr!s rtrr"rsEHrwcgrprqr!s rtrr"urrwc4URRUS9$)aReturns all data in the DataFrame as a list of rows of python-native values. Arguments: named: By default, each row is returned as a tuple of values given in the same order as the frame columns. Setting named=True will return rows of dictionaries instead. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> nw.from_native(df_native).rows() [(1, 6.0), (2, 7.0)] r)rkrr!s rtrr"xs"$$)))66rwc## URR5HnURXRS9v M g7f)uReturns an iterator over the columns of this DataFrame. Yields: A Narwhals Series, backed by a native series. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> iter_columns = nw.from_native(df_native).iter_columns() >>> next(iter_columns) ┌───────────────────────┐ | Narwhals Series | |-----------------------| |0 1 | |1 2 | |Name: foo, dtype: int64| └───────────────────────┘ >>> next(iter_columns) ┌─────────────────────────┐ | Narwhals Series | |-------------------------| |0 6.0 | |1 7.0 | |Name: bar, dtype: float64| └─────────────────────────┘ rN)rk iter_columnsrxrm)rsrs rtr'DataFrame.iter_columnss58++88:F,,v[[,9 9;s>Ar buffer_sizecgrprqrsrr*s rt iter_rowsDataFrame.iter_rowss%(rw)r*cgrprqr,s rtr-r.s$'rwcgrprqr,s rtr-r.s @Crwic4URRXS9$)a'Returns an iterator over the DataFrame of rows of python-native values. Arguments: named: By default, each row is returned as a tuple of values given in the same order as the frame columns. Setting named=True will return rows of dictionaries instead. buffer_size: Determines the number of rows that are buffered internally while iterating over the data. See https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.iter_rows.html Notes: cuDF doesn't support this method. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> iter_rows = nw.from_native(df_native).iter_rows() >>> next(iter_rows) (1, 6.0) >>> next(iter_rows) (2, 7.0) r))rkr-r,s rtr-r.s4$$..U.TTrwc$>[TU]"U0UD6$)aAdd columns to this DataFrame. Added columns will replace existing columns with the same name. Arguments: *exprs: Column(s) to add, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs: Additional columns to add, specified as keyword arguments. The columns will be renamed to the keyword used. Note: Creating a new DataFrame using this method does not create a new copy of existing data. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "b": [0.5, 4.0]}) >>> ( ... nw.from_native(df_native) ... .with_columns((nw.col("a") * 2).alias("a*2")) ... .to_native() ... ) a b a*2 0 1 0.5 2 1 2 4.0 4 )rrrsrrrs rtrDataFrame.with_columnss@w#U:k::rwc$>[TU]"U0UD6$)uSelect columns from this DataFrame. Arguments: *exprs: Column(s) to select, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs: Additional columns to select, specified as keyword arguments. The columns will be renamed to the keyword used. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"a": [1, 2], "b": [3, 4]}) >>> nw.from_native(df_native).select("a", a_plus_1=nw.col("a") + 1) ┌──────────────────┐ |Narwhals DataFrame| |------------------| |pyarrow.Table | |a: int64 | |a_plus_1: int64 | |---- | |a: [[1,2]] | |a_plus_1: [[2,3]] | └──────────────────┘ )rrr3s rtrDataFrame.selects:w~u4 44rwc">[TU]U5$)aRename column names. Arguments: mapping: Key value pairs that map from old name to new name. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "bar": [6, 7]}) >>> nw.from_native(df_native).rename({"foo": "apple"}).to_native() pyarrow.Table apple: int64 bar: int64 ---- apple: [[1,2]] bar: [[6,7]] rrrsrrs rtrDataFrame.renames$w~g&&rwc">[TU]U5$)anGet the first `n` rows. Arguments: n: Number of rows to return. If a negative value is passed, return all rows except the last `abs(n)`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "b": [0.5, 4.0]}) >>> nw.from_native(df_native).head(1).to_native() a b 0 1 0.5 rrrsrrs rtrDataFrame.head*sw|Arwc">[TU]U5$)u,Get the last `n` rows. Arguments: n: Number of rows to return. If a negative value is passed, return all rows except the first `abs(n)`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2], "b": [0.5, 4.0]}) >>> nw.from_native(df_native).tail(1) ┌──────────────────┐ |Narwhals DataFrame| |------------------| | a b | | 1 2 4.0 | └──────────────────┘ )rrr=s rtrDataFrame.tail;&w|Arwrc6>[TU]"[U5SU06$)a'Remove columns from the dataframe. Arguments: *columns: Names of the columns that should be removed from the dataframe. strict: Validate that all column names exist in the schema and throw an exception if a column name does not exist in the schema. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [1, 2], "bar": [6.0, 7.0], "ham": ["a", "b"]} ... ) >>> nw.from_native(df_native).drop("ham").to_native() foo bar 0 1 6.0 1 2 7.0 rrrrrsrrrs rtrDataFrame.dropPs&w|WW-=f==rwanykeepmaintain_orderr c US;aSSSU3n[U5e[U[5(aU/nURURR XX4S95$)aDrop duplicate rows from this dataframe. Arguments: subset: Column name(s) to consider when identifying duplicate rows. keep: {'first', 'last', 'any', 'none'} Which of the duplicate rows to keep. * 'any': Does not give any guarantee of which row is kept. This allows more optimizations. * 'none': Don't keep duplicate rows. * 'first': Keep first unique row. * 'last': Keep last unique row. maintain_order: Keep the same order as the original DataFrame. This may be more expensive to compute. order_by: Column(s) to order by when computing the row index. Nulls are placed first. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [1, 2], "bar": ["a", "a"], "ham": ["b", "b"]} ... ) >>> nw.from_native(df_native).unique(["bar", "ham"]).to_native() foo bar ham 0 1 a b >rFlastnonefirst Expected rFrLrMrKrrG)r!rrrrkunique)rsrrHrIr rs rtrPDataFrame.uniqueesqD 7 7<=WTFKCS/ ! fc " "XF##  ! ! ( (. )   rwcZ>^^TRmUU4SjU5n[TT]"U0UD6$)aFilter the rows in the DataFrame based on one or more predicate expressions. The original order of the remaining rows is preserved. Arguments: *predicates: Expression(s) that evaluates to a boolean Series. Can also be a boolean list(s). **constraints: Column filters; use `name = value` to filter columns by the supplied value. Each constraint will behave the same as `nw.col(name).eq(value)`, and will be implicitly joined with the other filter conditions using &. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [1, 2, 3], "bar": [6, 7, 8], "ham": ["a", "b", "c"]} ... ) Filter on one condition >>> nw.from_native(df_native).filter(nw.col("foo") > 1).to_native() foo bar ham 1 2 7 b 2 3 8 c Filter on multiple conditions with implicit `&` >>> nw.from_native(df_native).filter( ... nw.col("foo") < 3, nw.col("ham") == "a" ... ).to_native() foo bar ham 0 1 6 a Filter on multiple conditions with `|` >>> nw.from_native(df_native).filter( ... (nw.col("foo") == 1) | (nw.col("ham") == "c") ... ).to_native() foo bar ham 0 1 6 a 2 3 8 c Filter using `**kwargs` syntax >>> nw.from_native(df_native).filter(foo=2, ham="b").to_native() foo bar ham 1 2 7 b c3># UH7n[U[5(aTRRSUTS9OUv M9 g7f)rN)r&r[rx from_iterable)rpimplrss rtr#DataFrame.filter..sB @J!T?R?RDLL & &r1d & ;XY Ys?A)rnrr)rsrrparsed_predicatesrWrs` @rtrDataFrame.filters8f""  w~0@K@@rwdrop_null_keyscgrprqrsr\keyss rtgroup_byDataFrame.group_byrwcgrprqr^s rtr`rarbrwc^ ^ SSKJn [U5n[SU55(aU"XUS9$SSKJn SSKJm SSKJ m [U U 4SjU55nU(a[U5(a S n[U5e[XFS S 9VV s/sHupU (aUOU"U5PM n nn UR"U 6n [U S S 06 U"X US9$s sn nf)a<Start a group by operation. Arguments: *keys: Column(s) to group by. Accepts expression input. Strings are parsed as column names. drop_null_keys: if True, then groups where any key is null won't be included in the result. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... { ... "a": ["a", "b", "a", "b", "c"], ... "b": [1, 2, 1, 3, 3], ... "c": [5, 4, 3, 2, 1], ... } ... ) Group by one column and compute the sum of another column >>> nw.from_native(df_native, eager_only=True).group_by("a").agg( ... nw.col("b").sum() ... ).sort("a").to_native() a b 0 a 2 1 b 5 2 c 3 Group by multiple columns and compute the max of another column >>> ( ... nw.from_native(df_native, eager_only=True) ... .group_by(["a", "b"]) ... .agg(nw.max("c")) ... .sort("a", "b") ... .to_native() ... ) a b c 0 a 1 5 1 b 2 4 2 b 3 2 3 c 3 1 Expressions are also accepted. >>> nw.from_native(df_native, eager_only=True).group_by( ... "a", nw.col("b") // 2 ... ).agg(nw.col("c").mean()).to_native() a b c 0 a 0 4.0 1 b 1 3.0 2 c 1 1.0 r)rOc3B# UHn[U[5v M g7frprrrs rtr%DataFrame.group_by..9yz#s##yrr[rExprr5c3@># UHn[UTT45v M g7frpr)rrrkr6s rtrrgs%WYjT6N&C&CYsz?drop_null_keys cannot be True when keys contains Expr or SeriesTrrzDataFrame.group_by)narwhals.group_byrOrrnarwhalsr narwhals.exprrkrr6rrFr ziprr)rsr\r_rO flat_keysrkey_is_expr_or_seriesrris_expr_keysexpr_flat_keysrkr6s @@rtr`rasr .DM 9y9 9 94>J J &* %%WY%W W c"788SC%c* *")4P P Ac!f $P  22E:)  +? tNKK s C rc,>[TU]"U/UQ7X#S.6$)uSort the dataframe by the given columns. Arguments: by: Column(s) names to sort by. *more_by: Additional columns to sort by, specified as positional arguments. descending: Sort in descending order. When sorting by multiple columns, can be specified per column by passing a sequence of booleans. nulls_last: Place null values last. Note: Unlike Polars, it is not possible to specify a sequence of booleans for `nulls_last` in order to control per-column behaviour. Instead a single boolean is applied for all `by` columns. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"foo": [2, 1], "bar": [6.0, 7.0], "ham": ["a", "b"]} ... ) >>> nw.from_native(df_native).sort("foo") ┌──────────────────┐ |Narwhals DataFrame| |------------------| | foo bar ham | | 1 1 7.0 b | | 0 2 6.0 a | └──────────────────┘ rrrrsrrrrrs rtrDataFrame.sort*sHw|BWWZWWrwr c >[TU]XUS9$)uiReturn the `k` largest rows. Non-null elements are always preferred over null elements, regardless of the value of reverse. The output is not guaranteed to be in any particular order, sort the outputs afterwards if you wish the output to be sorted. Arguments: k: Number of rows to return. by: Column(s) used to determine the top rows. Accepts expression input. Strings are parsed as column names. reverse: Consider the k smallest elements of the by column(s) (instead of the k largest). This can be specified per column by passing a sequence of booleans. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame( ... {"a": ["a", "b", "a", "b", None, "c"], "b": [2, 1, 1, 3, 2, 1]} ... ) >>> nw.from_native(df_native).top_k(4, by=["b", "a"]) ┌──────────────────┐ |Narwhals DataFrame| |------------------| | a b | | 3 b 3 | | 0 a 2 | | 4 NaN 2 | | 5 c 1 | └──────────────────┘ r rrrsrrr rs rtrDataFrame.top_kPs@w}Qw}77rw_rightrrrc ">[TU]XXEX&S9$)uJoin in SQL-like fashion. Arguments: other: DataFrame to join with. on: Name(s) of the join columns in both DataFrames. If set, `left_on` and `right_on` should be None. how: Join strategy. * *inner*: Returns rows that have matching values in both tables. * *left*: Returns all rows from the left table, and the matched rows from the right table. * *full*: Returns all rows in both dataframes, with the suffix appended to the right join keys. * *cross*: Returns the Cartesian product of rows from both tables. * *semi*: Filter rows that have a match in the right table. * *anti*: Filter rows that do not have a match in the right table. left_on: Join column of the left DataFrame. right_on: Join column of the right DataFrame. suffix: Suffix to append to columns with a duplicate name. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_1_native = pd.DataFrame({"id": ["a", "b"], "price": [6.0, 7.0]}) >>> df_2_native = pd.DataFrame({"id": ["a", "b", "c"], "qty": [1, 2, 3]}) >>> nw.from_native(df_1_native).join(nw.from_native(df_2_native), on="id") ┌──────────────────┐ |Narwhals DataFrame| |------------------| | id price qty | | 0 a 6.0 1 | | 1 b 7.0 2 | └──────────────────┘ rrrr$rrr"rsrr$rrrrrs rtr"DataFrame.joinrs#Tw| G2  rwr/rrr$r2r3rr4rc .>[T U]UUUUUUUUU S9 $)u Perform an asof join. This is similar to a left-join except that we match on nearest key rather than equal keys. For Polars, both DataFrames must be sorted by the `on` key (within each `by` group if specified). Arguments: other: DataFrame to join with. left_on: Name(s) of the left join column(s). right_on: Name(s) of the right join column(s). on: Join column of both DataFrames. If set, left_on and right_on should be None. by_left: join on these columns before doing asof join. by_right: join on these columns before doing asof join. by: join on these columns before doing asof join. strategy: Join strategy. The default is "backward". suffix: Suffix to append to columns with a duplicate name. * *backward*: selects the last row in the right DataFrame whose "on" key is less than or equal to the left's key. * *forward*: selects the first row in the right DataFrame whose "on" key is greater than or equal to the left's key. * *nearest*: search selects the last row in the right DataFrame whose value is nearest to the left's key. Examples: >>> from datetime import datetime >>> import pandas as pd >>> import narwhals as nw >>> data_gdp = { ... "datetime": [ ... datetime(2016, 1, 1), ... datetime(2017, 1, 1), ... datetime(2018, 1, 1), ... datetime(2019, 1, 1), ... datetime(2020, 1, 1), ... ], ... "gdp": [4164, 4411, 4566, 4696, 4827], ... } >>> data_population = { ... "datetime": [ ... datetime(2016, 3, 1), ... datetime(2018, 8, 1), ... datetime(2019, 1, 1), ... ], ... "population": [82.19, 82.66, 83.12], ... } >>> gdp_native = pd.DataFrame(data_gdp) >>> population_native = pd.DataFrame(data_population) >>> gdp = nw.from_native(gdp_native) >>> population = nw.from_native(population_native) >>> population.join_asof(gdp, on="datetime", strategy="backward") ┌──────────────────────────────┐ | Narwhals DataFrame | |------------------------------| | datetime population gdp| |0 2016-03-01 82.19 4164| |1 2018-08-01 82.66 4566| |2 2019-01-01 83.12 4696| └──────────────────────────────┘ rrr6 rsrrrr$r2r3rr4rrs rtr6DataFrame.join_asofs8Nw !  rwc$UR5)$)uGet a mask of all duplicated rows in this DataFrame. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [2, 2, 2], "bar": [6.0, 6.0, 7.0]}) >>> nw.from_native(df_native).is_duplicated() ┌───────────────┐ |Narwhals Series| |---------------| | 0 True | | 1 True | | 2 False | | dtype: bool | └───────────────┘ ) is_uniquerrs rt is_duplicatedDataFrame.is_duplicateds"   rwc[U5S:H$)zCheck if the dataframe is empty. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [2, 2, 2], "bar": [6.0, 6.0, 7.0]}) >>> nw.from_native(df_native).is_empty() False r)r#rrs rtis_emptyDataFrame.is_emptys4yA~rwcfURURR5URS9$)uGet a mask of all unique rows in this DataFrame. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [2, 2, 2], "bar": [6.0, 6.0, 7.0]}) >>> nw.from_native(df_native).is_unique() ┌───────────────┐ |Narwhals Series| |---------------| | 0 False | | 1 False | | 2 True | | dtype: bool | └───────────────┘ r)rxrkrrmrrs rtrDataFrame.is_uniques*"||D11;;=T[[|QQrwcURR5nURRUR5R 55nUR U5$)uCreate a new DataFrame that shows the null counts per column. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, None], "bar": [2, 3]}) >>> nw.from_native(df_native).null_count() ┌──────────────────┐ |Narwhals DataFrame| |------------------| | pyarrow.Table | | foo: int64 | | bar: int64 | | ---- | | foo: [[1]] | | bar: [[0]] | └──────────────────┘ )rkr|rr null_countr)rsplxr's rtrDataFrame.null_count&sN.##::<&&--cggi.B.B.DE##F++rwc4URRXS9$)aReturn the DataFrame as a scalar, or return the element at the given row/column. Arguments: row: The *n*-th row. column: The column selected via an integer or a string (column name). Notes: If row/col not provided, this is equivalent to df[0,0], with a check that the shape is (1,1). With row/col, this is equivalent to df[row,col]. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, None], "bar": [2, 3]}) >>> nw.from_native(df_native).item(0, 1) 2 )rcolumn)rkr)rsrrs rtrDataFrame.itemAs$$$))c)AArwcTURURR55$)z Create a copy of this DataFrame.)rrkclonerrs rtrDataFrame.cloneUs"##D$9$9$?$?$ABBrwc>[TU]XS9$)uRTake every nth row in the DataFrame and return as a new DataFrame. Arguments: n: Gather every *n*-th row. offset: Starting index. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, None, 2, 3]}) >>> nw.from_native(df_native).gather_every(2) ┌──────────────────┐ |Narwhals DataFrame| |------------------| | pyarrow.Table | | foo: int64 | | ---- | | foo: [[1,2]] | └──────────────────┘ r*)rr,)rsrr+rs rtr,DataFrame.gather_everyYs*w#a#77rw_)r;valuesaggregate_functionrI sort_columns separatorc HUcUc Sn[U5eUbSn[U[5 [U[5(aU/OUn[U[5(aU/OUn[U[5(aU/OUnUR UR RUUUUUUS95$)uCreate a spreadsheet-style pivot table as a DataFrame. Arguments: on: Name of the column(s) whose values will be used as the header of the output DataFrame. index: One or multiple keys to group by. If None, all remaining columns not specified on `on` and `values` will be used. At least one of `index` and `values` must be specified. values: One or multiple keys to group by. If None, all remaining columns not specified on `on` and `index` will be used. At least one of `index` and `values` must be specified. aggregate_function: Choose from - None: no aggregation takes place, will raise error if multiple values are in group. - A predefined aggregate function string, one of {'min', 'max', 'first', 'last', 'sum', 'mean', 'median', 'len'} maintain_order: Has no effect and is kept around only for backwards-compatibility. sort_columns: Sort the transposed columns by name. Default is by order of discovery. separator: Used as separator/delimiter in generated column names in case of multiple `values` columns. Examples: >>> import pandas as pd >>> import narwhals as nw >>> data = { ... "ix": [1, 1, 2, 2, 1, 2], ... "col": ["a", "a", "a", "a", "b", "b"], ... "foo": [0, 1, 2, 2, 7, 1], ... "bar": [0, 2, 0, 0, 9, 4], ... } >>> df_native = pd.DataFrame(data) >>> nw.from_native(df_native).pivot( ... "col", index="ix", aggregate_function="sum" ... ) ┌─────────────────────────────────┐ | Narwhals DataFrame | |---------------------------------| | ix foo_a foo_b bar_a bar_b| |0 1 1 7 2 9| |1 2 4 1 0 4| └─────────────────────────────────┘ z3At least one of `values` and `index` must be passedzx`maintain_order` has no effect and is only kept around for backwards-compatibility. You can safely remove this argument.)r$r;rrrr)r!r UserWarningrrrrkpivot) rsr$r;rrrIrrrs rtrDataFrame.pivotpsn >emGCS/ !  %7  #{ +C((bTb'44&&%eS11u##  ! ! ' '#5)# (   rwc6URR5$)a-Convert to arrow table. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, None], "bar": [2, 3]}) >>> nw.from_native(df_native).to_arrow() pyarrow.Table foo: double bar: int64 ---- foo: [[1,null]] bar: [[2,3]] )rkrrrs rtrDataFrame.to_arrows$$--//rw)fractionwith_replacementseedc|[X[U5US9nURURR XSUS95$)uSample from this DataFrame. Arguments: n: Number of items to return. Cannot be used with fraction. fraction: Fraction of items to return. Cannot be used with n. with_replacement: Allow values to be sampled more than once. seed: Seed for the random number generator. If set to None (default), a random seed is generated for each sample operation. Notes: The results may not be consistent across libraries. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2, 3], "bar": [19, 32, 4]}) >>> nw.from_native(df_native).sample(n=2) # doctest:+SKIP ┌──────────────────┐ |Narwhals DataFrame| |------------------| | foo bar | | 2 3 4 | | 1 2 32 | └──────────────────┘ )rrheightr)rrr)rr#rrksample)rsrrrrsizes rtrDataFrame.samplesNB$3t9GW ##  ! ! ( ( )   rwvariablerr;r<r=c >[TU]XX4S9$)uUnpivot a DataFrame from wide to long format. Optionally leaves identifiers set. This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (index) while all other columns, considered measured variables (on), are "unpivoted" to the row axis leaving just two non-identifier columns, 'variable' and 'value'. Arguments: on: Column(s) to use as values variables; if `on` is empty all columns that are not in `index` will be used. index: Column(s) to use as identifier variables. variable_name: Name to give to the `variable` column. Defaults to "variable". value_name: Name to give to the `value` column. Defaults to "value". Notes: If you're coming from pandas, this is similar to `pandas.DataFrame.melt`, but with `index` replacing `id_vars` and `on` replacing `value_vars`. In other frameworks, you might know this operation as `pivot_longer`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> data = {"a": ["x", "y", "z"], "b": [1, 3, 5], "c": [2, 4, 6]} >>> df_native = pd.DataFrame(data) >>> nw.from_native(df_native).unpivot(["b", "c"], index="a") ┌────────────────────┐ | Narwhals DataFrame | |--------------------| | a variable value| |0 x b 1| |1 y b 3| |2 z b 5| |3 x c 2| |4 y c 4| |5 z c 6| └────────────────────┘ r:rr>rsr$r;r<r=rs rtr>DataFrame.unpivots!^wm  rwc&>[TU]"U/UQ76$)uExplode the dataframe to long format by exploding the given columns. Notes: It is possible to explode multiple columns only if these columns must have matching element counts. Arguments: columns: Column names. The underlying columns being exploded must be of the `List` data type. *more_columns: Additional names of columns to explode, specified as positional arguments. Examples: >>> import polars as pl >>> import narwhals as nw >>> data = {"a": ["x", "y"], "b": [[1, 2], [3]]} >>> df_native = pl.DataFrame(data) >>> nw.from_native(df_native).explode("b").to_native() shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ x ┆ 1 │ │ x ┆ 2 │ │ y ┆ 3 │ └─────┴─────┘ rrJrsrrKrs rtrJDataFrame.explode- s8ww666rwrkrm)rNz.CompliantDataFrame[Any, Any, DataFrameT, Self])rNztype[Series[Any]])rNztype[LazyFrame[Any]]rPrrrrlrNrQ)rrIr&IntoBackend[EagerAllowed | PluginName]rNDataFrame[Any]rp)rzMapping[str, Any]r2IntoSchema | Mapping[str, IntoDType | None] | Nonerz-IntoBackend[EagerAllowed | PluginName] | NonerNr)rzSequence[Mapping[str, Any]]rrrrrNr)rr`rz!IntoSchema | Sequence[str] | NonerrrNr)rNrZ)NN)rrr bool | NonerNr`rNr)rz object | NonerNre)rzIntoBackend[LazyAllowed] | Nonerz Any | NonerNzLazyFrame[Any])rNrf)rNz pd.DataFrame)rNz pl.DataFrame)rrQrNrrzstr | Path | BytesIOrNrQ)rzstr | Path | BytesIO | NonerNrc)rNr`)rNztuple[int, int])rrrN Series[Any])b)rr^rNz int | float)rz-tuple[SingleIndexSelector, SingleColSelector]rNr)rz2str | tuple[MultiIndexSelector, SingleColSelector]rNr)rzSingleIndexSelector | MultiIndexSelector | MultiColSelector | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, MultiColSelector]rNrD)ra SingleIndexSelector | SingleColSelector | MultiColSelector | MultiIndexSelector | tuple[SingleIndexSelector, SingleColSelector] | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, SingleColSelector] | tuple[MultiIndexSelector, MultiColSelector]rNzSeries[Any] | Self | Any)rrrNr[)r Literal[True]rNzdict[str, Series[Any]])rLiteral[False]rNzdict[str, list[Any]])rr[rNz-dict[str, Series[Any]] | dict[str, list[Any]])r;rZrNztuple[Any, ...]rSrTr;)rrr str | Sequence[str] | NonerNrDrRrV)rrrNzlist[tuple[Any, ...]])rrrNzlist[dict[str, Any]])rr[rNz,list[tuple[Any, ...]] | list[dict[str, Any]])rNzIterator[Series[Any]])rrr*rZrNzIterator[tuple[Any, ...]])rrr*rZrNzIterator[dict[str, Any]])rr[r*rZrNz4Iterator[tuple[Any, ...]] | Iterator[dict[str, Any]]rWrXrYrr^rr[rNrD) rrUrHr_rIr[r rrNrD)rz*IntoExpr | Iterable[IntoExpr] | list[bool]rrrNrD)r_rOr\rrN GroupBy[Self])r_r^r\rrNr)r_rOr\r[rNrr]r`NrrrDr$rUrrXrrUrrUrrrNrDrrDrrcrrcr$rcr2rUr3rUrrUr4rQrrrNrD)rNr)rNr[rNrD)r int | Nonerzint | str | NonerNrrarb)r$zstr | list[str]r;rUrrUrzPivotAgg | NonerIrrr[rrrNrD)rNzpa.Table) rrrz float | Nonerr[rrrNrDrdrf)Krhrirjrk__doc__rMAINrrrlrmrurxr|rr classmethodrrrrrrrrrr8rrrrrrrrrrrrrrrrrrrrr'r-rrrrrrrPrr`rrr"r6rrrrrrr,rrrr>rJrn __classcell__rs@rtrprps0#*,,H. %% &5$58 5  55nFJ< BF <<C< ? <  <<|FJK)KCK 8 K  KKZ59GG2G 8 G  GGR/APN248Q# Q0Q Q  Qf3(1$1*66 @@5,2 ? + +W2?*ZZ F   :    p> :p> "p>d#47WW PP #'< < 6<<$(B B 6B4007477 7 78116" MQ  0J  8   (&.3RR HH WW %77 57&:>),(&(;>( "((:='%'47' !''14CC+.C =CC %UU36U =U8 ;3 ;DL ;  ;D535DL5 5>'("*BF>>.*.+ $)$/3 + &+ ! +  + - +  + Z8AE8AVY8A 8AtUX2DR (:G  LQRL2RLDHRL RLp-2 $X $X$X* $X  $X  $X$XNTY 8 80 8;P 8  8 8J&*# , +/+/, ,  #,  , ( , ), ,  , , d##*.+/%)%/Q Q  Q  Q  Q (Q )Q  #Q #Q Q  Q Q h!& R&,6B(C886)-)-.2&*"M M & M ' M , M $M M M  M ^0&( "&!& ( (  (  (  (  ( X&*1 )-'! 1 "1 & 1  1  1  1 1 f77rwrpc ^\rSrSr%Sr\R rS\S'\ S7Sj5r \ S8Sj5r S9Sjr S:Sjr S;S jrSS jjrS?S jrS@U4SjjrS=SAU4SjjjrSBSCSjjr\ SDU4Sjj5rSDU4Sjjr\ SEU4Sjj5rSFU4SjjrSFU4SjjrSGU4SjjrSHSIU4SjjjrSS.SJU4SjjjrS=SS S.SKSjjjrSLU4SjjrSMSjr\ S S!.SNS"jj5r!\ SOS#j5r!S$S!.SPS%jjr!S$S$S&.SQU4S'jjjr"S$S(.SRU4S)jjjr#SSS S S*S+.STU4S,jjjjr$S S S S S S S-S*S..SUU4S/jjjr%SVS0jr&S=S S1S2S3.SWU4S4jjjjr'SXU4S5jjr(S6r)U=r*$)Yr{iL apNarwhals 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) ``` rqrrcUR$rprtrrs rtruLazyFrame._compliant[ rvrwc[$rp)rprrs rtrLazyFrame._dataframe_ r~rwczURS:a Sn[U5eUR(a Sn[U5eg)NraMOrder-dependent expressions are not supported for use in LazyFrame. Hint: To make the expression valid, specify `order_by`. For example, if you have columns `'price'` and `'date'`: - Instead of `nw.col('price').cum_sum()` write `nw.col('price').cum_sum().over(order_by='date')`. - Instead of `nw.col('price').diff()` write `nw.col('price').diff().over(order_by='date')`. - Instead of `nw.col('price').first()` write `nw.col('price').first().over(order_by='date')` or `nw.col('price').first(order_by='date')`. See https://narwhals-dev.github.io/narwhals/concepts/order_dependence/.a1Length-changing expressions are not supported for use in LazyFrame, unless followed by an aggregation. Hints: - Instead of `lf.select(nw.col('a').head())`, use `lf.select('a').head() - Instead of `lf.select(nw.col('a').drop_nulls()).select(nw.sum('a'))`, use `lf.select(nw.col('a').drop_nulls().sum()) )n_orderable_opsr0 is_filtration)rsrrs rtrLazyFrame._validate_metadatac sN  # #a 'Z (, ,  ! !E (, , "rwcX lU [U5(aUR5UlgS[ U53n[ U5e)NzVExpected Polars LazyFrame or an object that implements `__narwhals_lazyframe__`, got: )rmr!__narwhals_lazyframe__rkrrrs rtrLazyFrame.__init__{ sE  !" % %$&$=$=$?D !jkoprksjtuC % %rwcR[SUR5R55$)NzNarwhals LazyFramerrrs rtrLazyFrame.__repr__ rrwcSn[U5e)Nz%Slicing is not supported on LazyFrame)r)rsrrs rtrLazyFrame.__getitem__ s5nrwNc URRnUcURU"S0UD6SS9$[R"U5n[ U5(aURU"U40UD6SS9$S[ [5SUS3n[U5e)u2 Materialize 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) Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 2), (3, 4) df(a, b)") >>> lf = nw.from_native(lf_native) >>> lf ┌──────────────────┐ |Narwhals LazyFrame| |------------------| |┌───────┬───────┐ | |│ a │ b │ | |│ int32 │ int32 │ | |├───────┼───────┤ | |│ 1 │ 2 │ | |│ 3 │ 4 │ | |└───────┴───────┘ | └──────────────────┘ >>> lf.collect() ┌──────────────────┐ |Narwhals DataFrame| |------------------| | pyarrow.Table | | a: int32 | | b: int32 | | ---- | | a: [[1,3]] | | b: [[2,4]] | └──────────────────┘ rrz-Unsupported `backend` value. Expected one of z or None, got: rrp) rkcollectrrrrrrr!)rsrrr eager_backendrs rtrLazyFrame.collect sx''// ???7#:6#:&?I I&33G<  / /??7=#CF#C6?R R>xH]?^>__no|n}}~orwc[USS9$)uConvert Narwhals LazyFrame to native one. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 2), (3, 4) df(a, b)") >>> nw.from_native(lf_native).to_native() ┌───────┬───────┐ │ a │ b │ │ int32 │ int32 │ ├───────┼───────┤ │ 1 │ 2 │ │ 3 │ 4 │ └───────┴───────┘ F)narwhals_object pass_throughr7rrs rtr8LazyFrame.to_native s"EBBrwc,>[TU]"U/UQ70UD6$)u:Pipe function call. Arguments: function: Function to apply. args: Positional arguments to pass to function. kwargs: Keyword arguments to pass to function. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 2), (3, 4) df(a, b)") >>> nw.from_native(lf_native).pipe(lambda x: x.select("a")).to_native() ┌───────┐ │ a │ │ int32 │ ├───────┤ │ 1 │ │ 3 │ └───────┘ rrs rtrLazyFrame.pipe s6w|H6t6v66rwc>[TU]US9$)uDrop rows that contain null values. Arguments: subset: Column name(s) for which null values are considered. If set to None (default), use all columns. Notes: pandas handles null values differently from Polars and PyArrow. See [null_handling](../concepts/null_handling.md) for reference. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, NULL), (3, 4) df(a, b)") >>> nw.from_native(lf_native).drop_nulls() ┌──────────────────┐ |Narwhals LazyFrame| |------------------| |┌───────┬───────┐ | |│ a │ b │ | |│ int32 │ int32 │ | |├───────┼───────┤ | |│ 3 │ 4 │ | |└───────┴───────┘ | └──────────────────┘ rrr s rtrLazyFrame.drop_nulls s6w!!00rwc[U[5(aU/OUnURURR XS95$)uInsert column which enumerates rows. Arguments: name: The name of the column as a string. The default is "index". order_by: Column(s) to order by when computing the row index. Nulls are placed first. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 5), (2, 4) df(a, b)") >>> nw.from_native(lf_native).with_row_index(order_by="a").sort("a").collect() ┌──────────────────┐ |Narwhals DataFrame| |------------------| | pyarrow.Table | | index: int64 | | a: int32 | | b: int32 | | ---- | | index: [[0,1]] | | a: [[1,2]] | | b: [[5,4]] | └──────────────────┘ >>> nw.from_native(lf_native).with_row_index(order_by="b").sort("a").collect() ┌──────────────────┐ |Narwhals DataFrame| |------------------| | pyarrow.Table | | index: int64 | | a: int32 | | b: int32 | | ---- | | index: [[1,0]] | | a: [[1,2]] | | b: [[5,4]] | └──────────────────┘ r rrs rtrLazyFrame.with_row_index sDP#-Xs";";XJ ##  ! ! 0 0 0 J  rwc>URR[RLaSn[ U[ 5 [ TU]$)aCGet an ordered mapping of column names to their data type. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).schema # doctest:+SKIP Schema({'a': Int32, 'b': Decimal(precision=2, scale=1)}) zResolving the schema of a LazyFrame is a potentially expensive operation. Use `LazyFrame.collect_schema()` to get the schema without this warning.)rkrrrV1rr1rr)rsrrs rtrLazyFrame.schemaK s?  ) ) ;[  #1 2w~rwc >[TU]5$)a<Get an ordered mapping of column names to their data type. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).collect_schema() Schema({'a': Int32, 'b': Decimal(precision=2, scale=1)}) rrs rtrLazyFrame.collect_schema^ rrwc>[TU]$)aGet column names. Note: The pandas-like and dask backends allow non-string column names (e.g. integers or booleans). While discouraged, this is supported, so the return type is not guaranteed to be `list[str]`. See [concepts - column names](../concepts/column_names.md) for details. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).columns ['a', 'b'] rrs rtrLazyFrame.columnsj rrwcZ>U(dU(d Sn[U5e[TU]"U0UD6$)uAdd columns to this LazyFrame. Added columns will replace existing columns with the same name. Arguments: *exprs: Column(s) to add, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs: Additional columns to add, specified as keyword arguments. The columns will be renamed to the keyword used. Note: Creating a new LazyFrame using this method does not create a new copy of existing data. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).with_columns(c=nw.col("a") + 1) ┌────────────────────────────────┐ | Narwhals LazyFrame | |--------------------------------| |┌───────┬──────────────┬───────┐| |│ a │ b │ c │| |│ int32 │ decimal(2,1) │ int32 │| |├───────┼──────────────┼───────┤| |│ 1 │ 4.5 │ 2 │| |│ 3 │ 2.0 │ 4 │| |└───────┴──────────────┴───────┘| └────────────────────────────────┘ z@At least one expression must be passed to LazyFrame.with_columns)r!rrrsrrrrs rtrLazyFrame.with_columns~ s/H[TCS/ !w#U:k::rwcZ>U(dU(d Sn[U5e[TU]"U0UD6$)uYSelect columns from this LazyFrame. Arguments: *exprs: Column(s) to select, specified as positional arguments. Accepts expression input. Strings are parsed as column names. **named_exprs: Additional columns to select, specified as keyword arguments. The columns will be renamed to the keyword used. Notes: If you'd like to select a column whose name isn't a string (for example, if you're working with pandas) then you should explicitly use `nw.col` instead of just passing the column name. For example, to select a column named `0` use `df.select(nw.col(0))`, not `df.select(0)`. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).select("a", a_plus_1=nw.col("a") + 1) ┌────────────────────┐ | Narwhals LazyFrame | |--------------------| |┌───────┬──────────┐| |│ a │ a_plus_1 │| |│ int32 │ int32 │| |├───────┼──────────┤| |│ 1 │ 2 │| |│ 3 │ 4 │| |└───────┴──────────┘| └────────────────────┘ z:At least one expression must be passed to LazyFrame.select)r!rrrs rtrLazyFrame.select s.D[NCS/ !w~u4 44rwc">[TU]U5$)uRename column names. Arguments: mapping: Key value pairs that map from old name to new name, or a function that takes the old name as input and returns the new name. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 4.5), (3, 2.) df(a, b)") >>> nw.from_native(lf_native).rename({"a": "c"}) ┌────────────────────────┐ | Narwhals LazyFrame | |------------------------| |┌───────┬──────────────┐| |│ c │ b │| |│ int32 │ decimal(2,1) │| |├───────┼──────────────┤| |│ 1 │ 4.5 │| |│ 3 │ 2.0 │| |└───────┴──────────────┘| └────────────────────────┘ r8r9s rtrLazyFrame.rename s2w~g&&rwc">[TU]U5$)u Get `n` rows. Arguments: n: Number of rows to return. Examples: >>> import dask.dataframe as dd >>> import narwhals as nw >>> lf_native = dd.from_dict({"a": [1, 2, 3], "b": [4, 5, 6]}, npartitions=1) >>> nw.from_native(lf_native).head(2).collect() ┌──────────────────┐ |Narwhals DataFrame| |------------------| | a b | | 0 1 4 | | 1 2 5 | └──────────────────┘ r<r=s rtrLazyFrame.head rArwTrc6>[TU]"[U5SU06$)uRemove columns from the LazyFrame. Arguments: *columns: Names of the columns that should be removed from the dataframe. strict: Validate that all column names exist in the schema and throw an exception if a column name does not exist in the schema. Warning: `strict` argument is ignored for `polars<1.0.0`. Please consider upgrading to a newer version or pass to eager mode. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 2), (3, 4) df(a, b)") >>> nw.from_native(lf_native).drop("a").to_native() ┌───────┐ │ b │ │ int32 │ ├───────┤ │ 2 │ │ 4 │ └───────┘ rrCrDs rtrLazyFrame.drop s6w|WW-=f==rwrF)rHr cUS;aSSSU3n[U5eUS;aU(d Sn[U5e[U[5(aU/nUR UR R XUS95$)uDrop duplicate rows from this LazyFrame. Arguments: subset: Column name(s) to consider when identifying duplicate rows. If set to `None`, use all columns. keep: {'any', 'none', 'first', 'last} Which of the duplicate rows to keep. * 'any': Does not give any guarantee of which row is kept. * 'none': Don't keep duplicate rows. * 'first': Keep the first row. Requires `order_by` to be specified. * 'last': Keep the last row. Requires `order_by` to be specified. order_by: Column(s) to order by when computing the row index. Nulls are placed first. Examples: >>> import duckdb >>> import narwhals as nw >>> lf_native = duckdb.sql("SELECT * FROM VALUES (1, 3), (1, 4) df(a, b)") >>> nw.from_native(lf_native).unique("a").sort("a", descending=True) ┌──────────────────┐ |Narwhals LazyFrame| |------------------| |┌───────┬───────┐ | |│ a │ b │ | |│ int32 │ int32 │ | |├───────┼───────┤ | |│ 1 │ 3 │ | |└───────┴───────┘ | └──────────────────┘ >rFrKrLrMrNrOr>rKrMznarwhals.LazyFrame makes no assumptions about row order, so only 'first' and 'last' are only supported if `order_by` is passed.)rrHr )r!r0rrrrkrP)rsrrHr rs rtrPLazyFrame.unique sJ 7 7<=WTFKCS/ ! $ $XQ (, , fc " "XF##  ! ! ( (H ( U  rwc>[SU55n[U5(a Sn[U5e[TU]"U0UD6$)u_ Filter the rows in the LazyFrame based on a predicate expression. The original order of the remaining rows is preserved. Arguments: *predicates: Expression(s) that evaluates to a boolean Series. **constraints: Column filters; use `name = value` to filter columns by the supplied value. Each constraint will behave the same as `nw.col(name).eq(value)`, and will be implicitly joined with the other filter conditions using &. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql(''' ... SELECT * FROM VALUES ... (1, 6, 'a'), ... (2, 7, 'b'), ... (3, 8, 'c') ... df(foo, bar, ham) ... ''') Filter on one condition >>> nw.from_native(df_native).filter(nw.col("foo") > 1).to_native() ┌───────┬───────┬─────────┐ │ foo │ bar │ ham │ │ int32 │ int32 │ varchar │ ├───────┼───────┼─────────┤ │ 2 │ 7 │ b │ │ 3 │ 8 │ c │ └───────┴───────┴─────────┘ Filter on multiple conditions with implicit `&` >>> nw.from_native(df_native).filter( ... nw.col("foo") < 3, nw.col("ham") == "a" ... ).to_native() ┌───────┬───────┬─────────┐ │ foo │ bar │ ham │ │ int32 │ int32 │ varchar │ ├───────┼───────┼─────────┤ │ 1 │ 6 │ a │ └───────┴───────┴─────────┘ Filter on multiple conditions with `|` >>> nw.from_native(df_native).filter( ... (nw.col("foo") == 1) | (nw.col("ham") == "c") ... ).to_native() ┌───────┬───────┬─────────┐ │ foo │ bar │ ham │ │ int32 │ int32 │ varchar │ ├───────┼───────┼─────────┤ │ 1 │ 6 │ a │ │ 3 │ 8 │ c │ └───────┴───────┴─────────┘ Filter using `**kwargs` syntax >>> nw.from_native(df_native).filter(foo=2, ham="b").to_native() ┌───────┬───────┬─────────┐ │ foo │ bar │ ham │ │ int32 │ int32 │ varchar │ ├───────┼───────┼─────────┤ │ 2 │ 7 │ b │ └───────┴───────┴─────────┘ c3\# UH"n[U5(a [U5OUv M$ g7frp)r$r)rrVs rtr#LazyFrame.filter.. s!Rz! AE!HA=zs*,zX`LazyFrame.filter` is not supported with Python boolean masks - use expressions instead.)rr*rrr)rsrr predicates_rrs rtrLazyFrame.filterO sDTRzRR +K 8 8lCC. w~{:k::rwc:URRU5 g)aWrite LazyFrame to Parquet file. This may allow larger-than-RAM datasets to be written to disk. Arguments: file: String, path object or file-like object to which the dataframe will be written. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.LazyFrame({"foo": [1, 2], "bar": [6.0, 7.0]}) >>> df = nw.from_native(df_native) >>> df.sink_parquet("out.parquet") # doctest:+SKIP N)rk sink_parquetrs rtrLazyFrame.sink_parquet s **40rw.r[cgrprqr^s rtr`LazyFrame.group_by  rwcgrprqr^s rtr`r rrwFc^ SSKJn [U5n[SU55(aU"XUS9$SSKJn SSKJm [U 4SjU55nU(a[U5(a Sn[U5e[XFS S 9VV s/sHupU (aUOU"U5PM n nn UR"U 6n [U S S 06 U"X US9$s sn nf) u Start a group by operation. Arguments: *keys: Column(s) to group by. Accepts expression input. Strings are parsed as column names. drop_null_keys: if True, then groups where any key is null won't be included in the result. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES (1, 'a'), (2, 'b'), (3, 'a') df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.group_by("b").agg(nw.col("a").sum()).sort("b").to_native() ┌─────────┬────────┐ │ b │ a │ │ varchar │ int128 │ ├─────────┼────────┤ │ a │ 4 │ │ b │ 2 │ └─────────┴────────┘ Expressions are also accepted. >>> df.group_by(nw.col("b").str.len_chars()).agg( ... nw.col("a").sum() ... ).to_native() ┌───────┬────────┐ │ b │ a │ │ int64 │ int128 │ ├───────┼────────┤ │ 1 │ 6 │ └───────┴────────┘ r)rPc3B# UHn[U[5v M g7frprrfs rtr%LazyFrame.group_by.. rhrr[rirjc3<># UHn[UT5v M g7frprm)rrrks rtrr sCAJq$//sz5drop_null_keys cannot be True when keys contains ExprTrrzLazyFrame.group_by)rnrPrrrorrprkrrFr rqrr) rsr\r_rPrrr key_is_exprrrrtrurvrks @rtr`r sR 2DM 9y9 9 9t~N N &CCC c+..IC%c* *")F F Ac!f $F  22E:)  +? 4OO sCrc,>[TU]"U/UQ7X#S.6$)uSort the LazyFrame by the given columns. Arguments: by: Column(s) names to sort by. *more_by: Additional columns to sort by, specified as positional arguments. descending: Sort in descending order. When sorting by multiple columns, can be specified per column by passing a sequence of booleans. nulls_last: Place null values last; can specify a single boolean applying to all columns or a sequence of booleans for per-column control. Warning: Unlike Polars, it is not possible to specify a sequence of booleans for `nulls_last` in order to control per-column behaviour. Instead a single boolean is applied for all `by` columns. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES (1, 6.0, 'a'), (2, 5.0, 'c'), (NULL, 4.0, 'b') df(a, b, c)" ... ) >>> df = nw.from_native(df_native) >>> df.sort("a") ┌──────────────────────────────────┐ | Narwhals LazyFrame | |----------------------------------| |┌───────┬──────────────┬─────────┐| |│ a │ b │ c │| |│ int32 │ decimal(2,1) │ varchar │| |├───────┼──────────────┼─────────┤| |│ NULL │ 4.0 │ b │| |│ 1 │ 6.0 │ a │| |│ 2 │ 5.0 │ c │| |└───────┴──────────────┴─────────┘| └──────────────────────────────────┘ rrxrys rtrLazyFrame.sort sVw|BWWZWWrwr c >[TU]XUS9$)uReturn the `k` largest rows. Non-null elements are always preferred over null elements, regardless of the value of reverse. The output is not guaranteed to be in any particular order, sort the outputs afterwards if you wish the output to be sorted. Arguments: k: Number of rows to return. by: Column(s) used to determine the top rows. Accepts expression input. Strings are parsed as column names. reverse: Consider the k smallest elements of the by column(s) (instead of the k largest). This can be specified per column by passing a sequence of booleans. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES ('a', 2), ('b', 1), ('a', 1), ('b', 3), (NULL, 2), ('c', 1) df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.top_k(4, by=["b", "a"]) ┌───────────────────┐ |Narwhals LazyFrame | |-------------------| |┌─────────┬───────┐| |│ a │ b │| |│ varchar │ int32 │| |├─────────┼───────┤| |│ b │ 3 │| |│ a │ 2 │| |│ NULL │ 2 │| |│ c │ 1 │| |└─────────┴───────┘| └───────────────────┘ r r|r}s rtrLazyFrame.top_k, sJw}Qw}77rwrrc ">[TU]XXEX&S9$)uAdd a join operation to the Logical Plan. Arguments: other: Lazy DataFrame to join with. on: Name(s) of the join columns in both DataFrames. If set, `left_on` and `right_on` should be None. how: Join strategy. * *inner*: Returns rows that have matching values in both tables. * *left*: Returns all rows from the left table, and the matched rows from the right table. * *full*: Returns all rows in both dataframes, with the suffix appended to the right join keys. * *cross*: Returns the Cartesian product of rows from both tables. * *semi*: Filter rows that have a match in the right table. * *anti*: Filter rows that do not have a match in the right table. left_on: Join column of the left DataFrame. right_on: Join column of the right DataFrame. suffix: Suffix to append to columns with a duplicate name. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native1 = duckdb.sql( ... "SELECT * FROM VALUES (1, 'a'), (2, 'b') df(a, b)" ... ) >>> df_native2 = duckdb.sql( ... "SELECT * FROM VALUES (1, 'x'), (3, 'y') df(a, c)" ... ) >>> df1 = nw.from_native(df_native1) >>> df2 = nw.from_native(df_native2) >>> df1.join(df2, on="a") ┌─────────────────────────────┐ | Narwhals LazyFrame | |-----------------------------| |┌───────┬─────────┬─────────┐| |│ a │ b │ c │| |│ int32 │ varchar │ varchar │| |├───────┼─────────┼─────────┤| |│ 1 │ a │ x │| |└───────┴─────────┴─────────┘| └─────────────────────────────┘ rrrs rtr"LazyFrame.joinS s#fw| G2  rwr/rc .>[T U]UUUUUUUUU S9 $)u Perform an asof join. This is similar to a left-join except that we match on nearest key rather than equal keys. For Polars, both DataFrames must be sorted by the `on` key (within each `by` group if specified). Arguments: other: DataFrame to join with. left_on: Name(s) of the left join column(s). right_on: Name(s) of the right join column(s). on: Join column of both DataFrames. If set, left_on and right_on should be None. by_left: join on these columns before doing asof join by_right: join on these columns before doing asof join by: join on these columns before doing asof join strategy: Join strategy. The default is "backward". * *backward*: selects the last row in the right DataFrame whose "on" key is less than or equal to the left's key. * *forward*: selects the first row in the right DataFrame whose "on" key is greater than or equal to the left's key. * *nearest*: search selects the last row in the right DataFrame whose value is nearest to the left's key. suffix: Suffix to append to columns with a duplicate name. Examples: >>> from datetime import datetime >>> import polars as pl >>> import narwhals as nw >>> data_gdp = { ... "datetime": [ ... datetime(2016, 1, 1), ... datetime(2017, 1, 1), ... datetime(2018, 1, 1), ... datetime(2019, 1, 1), ... datetime(2020, 1, 1), ... ], ... "gdp": [4164, 4411, 4566, 4696, 4827], ... } >>> data_population = { ... "datetime": [ ... datetime(2016, 3, 1), ... datetime(2018, 8, 1), ... datetime(2019, 1, 1), ... ], ... "population": [82.19, 82.66, 83.12], ... } >>> gdp_native = pl.DataFrame(data_gdp) >>> population_native = pl.DataFrame(data_population) >>> gdp = nw.from_native(gdp_native) >>> population = nw.from_native(population_native) >>> population.join_asof(gdp, on="datetime", strategy="backward").to_native() shape: (3, 3) ┌─────────────────────┬────────────┬──────┐ │ datetime ┆ population ┆ gdp │ │ --- ┆ --- ┆ --- │ │ datetime[μs] ┆ f64 ┆ i64 │ ╞═════════════════════╪════════════╪══════╡ │ 2016-03-01 00:00:00 ┆ 82.19 ┆ 4164 │ │ 2018-08-01 00:00:00 ┆ 82.66 ┆ 4566 │ │ 2019-01-01 00:00:00 ┆ 83.12 ┆ 4696 │ └─────────────────────┴────────────┴──────┘ rrrs rtr6LazyFrame.join_asof s8Tw !  rwcU$)z}Restrict available API methods to lazy-only ones. This is a no-op, and exists only for compatibility with `DataFrame.lazy`. rqrrs rtrLazyFrame.lazy s  rwrrrc >[TU]XX4S9$)uaUnpivot a DataFrame from wide to long format. Optionally leaves identifiers set. This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (index) while all other columns, considered measured variables (on), are "unpivoted" to the row axis leaving just two non-identifier columns, 'variable' and 'value'. Arguments: on: Column(s) to use as values variables; if `on` is empty all columns that are not in `index` will be used. index: Column(s) to use as identifier variables. variable_name: Name to give to the `variable` column. Defaults to "variable". value_name: Name to give to the `value` column. Defaults to "value". Notes: If you're coming from pandas, this is similar to `pandas.DataFrame.melt`, but with `index` replacing `id_vars` and `on` replacing `value_vars`. In other frameworks, you might know this operation as `pivot_longer`. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES ('x', 1, 2), ('y', 3, 4), ('z', 5, 6) df(a, b, c)" ... ) >>> df = nw.from_native(df_native) >>> df.unpivot(on=["b", "c"], index="a").sort("a", "variable").to_native() ┌─────────┬──────────┬───────┐ │ a │ variable │ value │ │ varchar │ varchar │ int32 │ ├─────────┼──────────┼───────┤ │ x │ b │ 1 │ │ x │ c │ 2 │ │ y │ b │ 3 │ │ y │ c │ 4 │ │ z │ b │ 5 │ │ z │ c │ 6 │ └─────────┴──────────┴───────┘ r:rrs rtr>LazyFrame.unpivot s!dwm  rwc&>[TU]"U/UQ76$)uFExplode the dataframe to long format by exploding the given columns. Notes: It is possible to explode multiple columns only if these columns have matching element counts. Arguments: columns: Column names. The underlying columns being exploded must be of the `List` data type. *more_columns: Additional names of columns to explode, specified as positional arguments. Examples: >>> import duckdb >>> import narwhals as nw >>> df_native = duckdb.sql( ... "SELECT * FROM VALUES ('x', [1, 2]), ('y', [3, 4]), ('z', [5, 6]) df(a, b)" ... ) >>> df = nw.from_native(df_native) >>> df.explode("b").to_native() ┌─────────┬───────┐ │ a │ b │ │ varchar │ int32 │ ├─────────┼───────┤ │ x │ 1 │ │ x │ 2 │ │ y │ 3 │ │ y │ 4 │ │ z │ 5 │ │ z │ 6 │ └─────────┴───────┘ rrs rtrJLazyFrame.explode s@ww666rwr)rNz)CompliantLazyFrame[Any, LazyFrameT, Self])rNztype[DataFrame[Any]]rPrr)rz str | slicerNr rp)rz+IntoBackend[Polars | Pandas | Arrow] | NonerrrNr)rNrerSrTr)rrr rgrNrDrRrVrWrXrrYr)rrUrHr_r rrNrDr\r)r_rOr\rrNLazyGroupBy[Self])r_r^r\rrNr*)r_rOr\r[rNr*r]r`rrrrrdrf)+rhrirjrkrrrrrrlrmrurrrrrrr8rrrrrrrrrrrrPrrrr`rrr"r6rr>rJrnrrs@rtr{r{L s& #*,,H. %%-0&P FJCBCUXC CJC(7477 7 7:11<"+ + 0C+ + Z$ (&';3';DL'; ';R%53%5DL%5 %5N'6*BF>>>*.2 $)/3 2 &2 ! 2 - 2  2 hO;8O;ILO; O;b1$UX 2 DR    ( :G   LQAP2APDHAP APN-2 +X +X+X* +X  +X  +X+X\TY%8%80%8;P%8 %8%8T&*# 5 +/+/5 5  #5  5 ( 5 )5 5  5 5 v##*.+/%)%/T T  T  T  T (T )T  #T #T T  T T l&*4 )-'! 4 "4 & 4  4  4  4 4 l 7 7rwr{) __future__rabcr functoolsr itertoolsrtypingrrr r r r r rrnarwhals._exceptionsrnarwhals._expression_parsingrrrnarwhals._typingrrrrnarwhals._utilsrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,narwhals.dependenciesr-r.narwhals.exceptionsr/r0r1rr2r3narwhals.schemar4rr6narwhals.translater8collections.abcr9r:r;r<r=ior>pathlibr?typesr@rArBpandaspdpolarsplpyarrowpatyping_extensionsrCrDnarwhals._compliantrErFnarwhals._compliant.typingrGrHnarwhals._translaterIrJrKrLrMrNrnrOrPnarwhals.typingrQrRrSrTrUrVrWrXrY_MultiColSelectorrZ_MultiIndexSelectorr[r\r]r^r_r`rarbrlrcrerfrgrirpr{rqrwrtrIs_"   / TS.F F""(OO -1J;927& 4BJ  ); / \ 9 \ 9  CL>)> BIBRW RWj B7 *%B7J