Wh $UddlmZddlmZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZmZddlmZddlmZmZmZmZddlmZmZmZmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd l0m1Z1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7dd l8m9Z9m:Z:dd l;mZ>ddl?m@Z@erddlAmBZBmCZCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKddlLZMddlNZOddlPZQddlRmSZSmTZTmUZUmVZVddlWmXZXmYZYddlZm[Z[m\Z\ddl]m^Z^ddlm_Z_m`Z`maZambZbddlcmdZdmeZeddlfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZompZqmrZrmsZsmtZtmuZumvZvmwZweTdZxeZydezd<edd Z{ed!d" Z|ed#d$ Z}ed%Z~d&Zndezd'<d(Zpdezd)<Gd*d+e e{ZGd,d-ee}ZGd.d/ee|Zy)0) annotations)abstractmethod)chain) TYPE_CHECKINGAnyCallableClassVarGenericLiteralNoReturnTypeVarget_argsoverload) issue_warning)ExprKind!check_expressions_preserve_lengthis_into_expr_eageris_scalar_like)ArrowPandas_LazyAllowedImpl_LazyFrameCollectImpl)ImplementationVersion_Implementationcan_lazyframe_collectcheck_columns_existflatten generate_repris_compliant_dataframeis_compliant_lazyframeis_eager_allowedis_index_selectoris_lazy_allowed is_list_ofis_sequence_like is_slice_nonequalified_type_namesupports_arrow_c_stream zip_strict)is_numpy_array_2dis_pyarrow_table)ColumnNotFoundErrorInvalidIntoExprErrorInvalidOperationErrorPerformanceWarning)_from_dict_no_backend_is_into_schema)SchemaSeries to_native)IterableIteratorMappingSequence)BytesIO)Path) ModuleTypeN) Concatenate ParamSpecSelf TypeAlias)CompliantDataFrameCompliantLazyFrame)CompliantExprAnyEagerNamespaceAny)IntoArrowTable) EagerAllowed IntoBackend LazyAllowedPolars)GroupBy LazyGroupBy)AsofJoinStrategy IntoDataFrameIntoExpr IntoFrame IntoLazyFrame IntoSchema JoinStrategyMultiColSelectorMultiIndexSelectorPivotAggSingleColSelectorSingleIndexSelectorSizeUnitUniqueKeepStrategy_2DArrayPSrB Incomplete_FrameTrQ)bound LazyFrameTrR DataFrameTrORz_MultiColSelector[Series[Any]]rUz _MultiIndexSelector[Series[Any]]rVceZdZUded<ded<eZded< eed(dZd)dZ d(d Z d*d Z d+d Z ed,d Z d-d Zd.dZed/dZd/dZ d0dZd1dZed2dZ d3dZ d3dZd4dZd5dZd5dZd6dZ d7dZddd d8dZdd d9dZ d:d Zd;dd#Z!d?d$Z"d?d%Z#d@d&Z$y')A BaseFramer_compliant_frame&Literal['full', 'lazy', 'interchange']_levelrimplementationcyNselfs L/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/dataframe.py _compliantzBaseFrame._compliants!$c6|jjSrk)rf__native_namespace__rms rorszBaseFrame.__native_namespace__s$$99;;rqc6|jjSrk)rf__narwhals_namespace__rms roruz BaseFrame.__narwhals_namespace__s$$;;==rqc<|j||jS)Nlevel) __class__rh)rndfs ro_with_compliantzBaseFrame._with_compliants~~b ~44rqcg}g}t|D]J}|j|}|j||jtj|dL|j D]\\}}|j|j |}|j||jtj|d^||fSNF str_as_lit)r_extract_compliantappendrfrom_into_expritemsalias)rnexprs named_exprs out_exprs out_kindsexprcompliant_exprrs ro_flatten_and_extractzBaseFrame._flatten_and_extracts   EN ND!44T:N   ^ ,   X44TeL M N',,. NKE4!44T:@@GN   ^ ,   X44TeL M N)##rqctrkNotImplementedError)rnargs rorzBaseFrame._extract_compliants!!rqct|t|r |jSdt|dt|}t |)NzExpected `other` to be a , got: ) isinstancetyperfr( TypeErrorrnothermsgs ro_extract_compliant_framez"BaseFrame._extract_compliant_framesG eT$Z ()) ))*=d*C)FgNabgNhMklnrqc0t||jS)N) available)rcolumnsrnsubsets ro_check_columns_existzBaseFrame._check_columns_exists"6T\\BBrqc\t|jjjSrk)r3rfschemarrms rorzBaseFrame.schemas"d++2288:;;rqc^t|jj}t|Srk)dictrfcollect_schemar3)rn native_schemas rorzBaseFrame.collect_schemas&T22AACD m$$rqc||g|i|Srkrl)rnfunctionargskwargss ropipezBaseFrame.pipes .t.v..rqct|tr|gn|}|j|jj |S)Nr)rstrr{rf drop_nullsrs rorzBaseFrame.drop_nullss9'4&&##D$9$9$D$DF$D$STTrqc.|jjSrk)rfrrms rorzBaseFrame.columnss$$,,,rqc|j|i|\}}t||Dcgc]#\}}t|r|j|n|%}}}|j |j j |Scc}}wrk)rr*r broadcastr{rf with_columns)rnrrcompliant_exprskindsrkinds rorzBaseFrame.with_columnss";!:!:E!Q[!Q)3?E(J $/=T.BN $ $T * V  ##$FD$9$9$F$F$XYY  s(A8cjtt|}|r=td|Dr+|s) |j|jj |S|j|i|\}}|r:td|Dr(|j|jj|St||D cgc]#\}} t| r|j| n|%}}} |j|jj|S#t $r}|j|x}r||d}~wwxYwcc} }w)Nc3<K|]}t|tywrkrr).0xs ro z#BaseFrame.select..sEQjC0Ec32K|]}t|ywrk)rrrs rorz#BaseFrame.select..s"JD>$#7"Js)tuplerallr{rf simple_select Exceptionrr aggregater*rrselect) rnrr flat_exprseerrorrrrrs rorzBaseFrame.selectsD75>* #E*EEk ++7D))77D";!:!:J!V+!V s"JE"JJ''(G(=(=(G(G(YZ Z)3?E(J $/=T.BN $ $T * V  ##$@D$9$9$@$@/$RSS  55jAA5AQ&   s'D4(D/ D,D''D,cV|j|jj|Srk)r{rfrename)rnmappings rorzBaseFrame.renames$##D$9$9$@$@$IJJrqcV|j|jj|Srk)r{rfheadrnns rorzBaseFrame.head$##D$9$9$>$>q$ABBrqcV|j|jj|Srk)r{rftailrs rorzBaseFrame.tailrrqcZ|j|jj||S)Nstrict)r{rfdrop)rnrrs rorzBaseFrame.drops)##D$9$9$>$>wv$>$VWWrqc t|dk(rt|dtr|d}ntddlmt |}t |ddi|j |j|\}} fd|jD} jt||ddi}|j|jj|S) Nrcol function_namefilterc3XK|]!\}}||k(j#ywrk)_to_compliant_expr)rnamevrplxs rorz#BaseFrame.filter..s0%D!Ta33C8%s'* ignore_nullsF)lenr%boolnarwhals.functionsrrrrurrall_horizontalrr{rfr) rn predicates constraints predicateflat_predicatescompliant_predicates_kindscompliant_constraintsrrs @@rorzBaseFrame.filters z?a Jz!}d$C"1 I .%j1O - Wh W--/C+D4+D+Do+V ( &%*002% !+**+-BCRWI##D$9$9$@$@$KLLrqF descending nulls_lastctgt|g|}|j|jj|||dS)Nr)rr{rfsort)rnbyrrmore_bys rorzBaseFrame.sort sL/wt}/w/ 0## &D ! ! & &zj Y  rqreversectt|g}|j|jj|||S)Nrr)rr{rftop_k)rnkrr flatten_bys rorzBaseFrame.top_ks=bT] ##  ! ! ' 'j' ' J  rqchd}t|tr|gn|}t|tr|gn|}t|tr|gn|}|j}|j|}||vrd|d|d} t | |dk(r*||| d} t | |j ||dd|} n}|P||d|d } t | t|t|k7r d } t | |j |||||} n+||d |d } t | |j |||||} |j| S) 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 ) rrrfrr ValueErrorjoinrr{) rnronrrrr_supported_joins compliantrresults ror zBaseFrame.joinsNC(bTb)'377)W!+Hc!:H:)) --e4 & &FGWFXXabeaffhiC%c* * '>"h&:bnV o%^^3tF$FZ("2_`c_ddef o%7|s8},K o%^^3(6$F"h&:Z[^Z__`a o%^^3R$F##F++rqcZ|j|jj||S)Nroffset)r{rf gather_every)rnrrs rorzBaseFrame.gather_everyKs.##  ! ! . .6 . B  rqc Jd} || vrd| d|d} t| ||| d} t| ||| d} t| ||||| d} t| ||| d} t| ||x}}||x}}t|tr|gn|}t|tr|gn|}t|tr4t|tr$t |t |k7r d } t| |j |jj|j||||||| S) 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) rrrrlistrr{rf join_asofr) rnrrrr rrrrr_supported_strategiesrs rorzBaseFrame.join_asofPs!C 0 0ABWAXXabjakkmnC%c* * JW_0@WCS/ ! N!48LRCS/ ! J _!5#(8Z S/ ! N!48LRCS/ ! >!# #Gh >!# #Gh)'377)W!+Hc!:H: w %*Xt*D LCM )GCS/ !##  ! ! + +--e4!!! ,   rqct|tr|gn|}t|tr|gn|}|j|jj ||||S)Nr index variable_name value_name)rrr{rfunpivot)rnr rrr s ror!zBaseFrame.unpivots] C(bTb%eS1u##  ! ! ) )U-J *   rqcd}t|)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)rrs ro__neq__zBaseFrame.__neq__ + "#&&rqcd}t|)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)rrs ro__eq__zBaseFrame.__eq__r$rqct|tr|g|ng||}|j|jj |S)Nr)rrr{rfexplode)rnr more_columns to_explodes ror)zBaseFrame.explodesT'3' $| $*7*\*  ##D$9$9$A$A*$A$UVVrqN)returnr)r,r>)rzrr,rA)rIntoExpr | Iterable[IntoExpr]rrPr,z-tuple[list[CompliantExprAny], list[ExprKind]]rrr,r)rz Self | Anyr,r)rz Sequence[str]r,zColumnNotFoundError | Noner,r3rz"Callable[Concatenate[Self, PS], R]rzPS.argsrz PS.kwargsr,rcrstr | list[str] | Noner,rAr,z list[str]rr-rrPr,rArzdict[str, str]r,rArintr,rA)rz Iterable[str]rrr,rArz*IntoExpr | Iterable[IntoExpr] | list[bool]rrr,rA rstr | Iterable[str]rrrbool | Sequence[bool]rrr,rArr7rr:rr;r,rA)rr^r r2rrTrr2rr2rrr,rArrr7rr7r,rA)rr^r str | Nonerr?r r?rr2rr2rr2rrNrrr,rA r r2rr2rrr rr,rA)robjectr,r rstr | Sequence[str]r*rr,rA)%__name__ __module__ __qualname____annotations__rripropertyrrprsrur{rrrrrrrrrrrrrrrrrrr rrr!r#r&r)rlrqrorerehs 22&5&7NO7($$<>5$3$DL$ 6$""" C<<% /4// / /U--Z3ZDLZ ZT3TDLT T0KCCXMEMVYM M2-2      *      TY  0 ;P  ,,,, #,, ,, ( ,,),,,, ,,\ < <  <  <  < (< )<  #< #< <  < | " &        " ' 'Wrqrec feZdZUdZej Zded<edldZ dmdZ edndZ edodZ dpdZ e dqd Ze drd d  dsd Ze dr dtd ZdudZdvdwdZdxdZdrdydZ drd d dzdZd{dZd|dZd}dZedrd~dZeddZdrddZddZddZeddZddZdddZ eddZ!e dd Z!e dd!Z! dd"Z!dd#Z"ed$d%dd&Z#edd'Z#ed(d% dd)Z#d(d% dd*Z#dd+Z$ dfd, Z%drdfd- Z& dd d. dd/Z'edfd0 Z(dfd1 Z)edfd2 Z*ed3d4dd5Z+edd6Z+edd7Z+d3d4 dd8Z+dd9Z,ed$d$d: dd;Z-ed$d< dd=Z-ed$d< dd>Z-d3d?d: dd@Z- dfdA Z. dfdB Z/dfdC Z0ddfdD Z1ddfdE Z2d(dFdfdGZ3 drdHd3d dI ddJZ4 dfdK Z5ed$dL ddMZ6e ddNZ6d3dL ddOZ6d3d3dP dfdQZ7d3dR dfdSZ8 dd d dTdU dfdVZ9d d d d d d dWdTdX dfdYZ:ddZZ;dd[Zdvdd^Z?dd_Z@ddfd` ZAd d d d d3dadb ddcZBdddZC drd d3d de ddfZD drd dgdhdi dfdjZEdfdk ZFxZGS) DataFramea{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), ) ``` zClassVar[Version]_versionc|jSrkrfrms rorpzDataFrame._compliant$$$rqct|r#|j}|j|dStjt |r})rruparse_into_exprr.from_invalid_typer)rnrrs rorzDataFrame._extract_compliantsC c "%)%@%@%BC&&su&= ="44T#Y??rqctSrkr4rms ro_serieszDataFrame._seriess rqctSrk) LazyFramerms ro _lazyframezDataFrame._lazyframerqc||_|t|r|j|_ydt |}t |)NzCExpected an object which implements `__narwhals_dataframe__`, got: )rhr __narwhals_dataframe__rfrAssertionErrorrnrzrxrs ro__init__zDataFrame.__init__sD>C  !" %$&$=$=$?D !WX\]_X`WabC % %rqctt|s%t|sdt|d}t|t j |}t |rV|jjj |j}|jj||}||dS|d|d}t|)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)contextrrwz 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"rK namespacer  _dataframe from_arrowr)cls native_framebackendrrinsr s rorczDataFrame.from_arrowsL( 59I,9W)$|*<)==bcCC. '44W= N +''44^DNNB 00r0JIy/ /HHVGWWY [ orqN)rfc6|t|\}}tj|}t|rW|jj j|j }|jj|||}||dS|d|d}t|)u)Instantiate DataFrame from dictionary. Indexes (if present, for pandas-like backends) are aligned following the [left-hand-rule](../concepts/pandas_index.md/). Notes: For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Dictionary to create DataFrame from. schema: The DataFrame schema as Schema or dict of {name: type}. If not specified, the schema will be inferred by the native library. backend: specifies which eager backend instantiate to. Only necessary if inputs are not Narwhals Series. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. 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 | └──────────────────┘ )rr^rrwz 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_) r1rr`r"rKrar rb from_dictr)rddatarrfrirgr rs rorizDataFrame.from_dict*sX ?1$7MD''44W= N +''44^DNNB //VR/PIy/ /TTbScce g orqctt|s d}t|t|sdt|d}t |t j |}t|rI|jjj |j}||j||dS|d|d}t|)uqConstruct 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`. 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 arrayszi`schema` is expected to be one of the following types: Mapping[str, DType] | Schema | Sequence[str]. Got rrrwz 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+rr2rrrr`r"rKrar  from_numpy)rdrjrrfrrirgs rorlzDataFrame.from_numpyesd!&=CS/ !v&F|nA'  C. '44W= N +''44^DNNBr}}T62&A AIIWHXXZ \ orqc6|jjSrk)rf__len__rms rornzDataFrame.__len__s$$,,..rqc<|jj||S)Ncopy)rf __array__)rndtyperqs rorrzDataFrame.__array__s$$..u4.@@rqcRtd|jjS)NzNarwhals DataFramerr7__repr__rms rorvzDataFrame.__repr__ 14>>3C3L3L3NOOrqc~|jj}t|r|j|S tj j }|dkrdt|}t|d|j}|j|S#t$r}dt|}t||d}~wwxYw)ahExport 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) rf _native_framer)__arrow_c_stream__rPYARROW_backend_versionModuleNotFoundErrorrto_arrow)rnryre pa_versionexcrpa_tables ror|zDataFrame.__arrow_c_stream__s,,:: "< 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 │ | |└───────┴───────┘ | └──────────────────┘ Nrlazyrwz(Not-supported backend. Expected one of z or `None`, got ) rfrrVrr`r$rrr)rnrfrr lazy_backendrs rorzDataFrame.lazysT$$)) ???4g#>f?M M%227; < (??4 g#Ff?U U:8DT;U:VVfgsftuorqc.|jjS)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 )rfr{rms ror7zDataFrame.to_natives$$$222rqc6|jjS)aConvert 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 )rf to_pandasrms rorzDataFrame.to_pandas3s $$..00rqc6|jjS)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 │ └─────┴─────┘ )rf to_polarsrms rorzDataFrame.to_polarsEs&$$..00rqcyrkrlrnfiles ro write_csvzDataFrame.write_csvZs36rqcyrkrlrs rorzDataFrame.write_csv]s=@rqc8|jj|S)aWrite 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. )rfrrs rorzDataFrame.write_csv`s($$..t44rqc:|jj|y)aWrite 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)rf write_parquetrs rorzDataFrame.write_parquetvs ++D1rqc<|jjddS)aiConvert 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. ]]) Nrp)rfto_numpyrms rorzDataFrame.to_numpys $$--d->>rqc.|jjS)aGet 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) )rfshaperms rorzDataFrame.shapes$$***rqcn|j|jj||jS)a Get 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 rw)rSrf get_columnrh)rnrs rorzDataFrame.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)rfestimated_size)rnrs rorzDataFrame.estimated_sizes"$$333>>rqcyrkrlrnitems ro __getitem__zDataFrame.__getitem__sWZrqcyrkrlrs rorzDataFrame.__getitem__srqcyrkrlrs rorzDataFrame.__getitem__srqcddlm}dt|d}t|tr[t |dkDr d}t ||rt|drdn|d}t |dkst|drdn|d}|E|C|St|r|}d}n1t|st|ttfrd}|}n t |t|tr t ||j}t|ttfr]t|tr|j||St|tr|n|j|}|j!|} || |S| St||r |j"}t||r |j"}||j%|dd|fS||j%||ddfS|j%|||fS) a Extract 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[['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 rr4z2Unexpected 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, :]`?Nr)narwhals.seriesr5rrrrrr'r#r&slicerrfr7rrr_compliant_seriesr{) rnrr5r tuple_msgrowsrr col_nameseriess rorzDataFrame.__getitem__sv +Ad MN N  dE "4y1}U **#}T!W'=447D!$i!m}T!W/Ed4PQ7G| t $DG d #z$ 'EDGC. dC C. )) gSz *$$yyw//",Wc":w W@UH__X.F#'#36$< ? ? dF #))D gv &//G <'' !W*(=> > ?'' $'(:; ;##IdGm$<==rqc||jvSrkr()rnkeys ro __contains__zDataFrame.__contains__Qsdll""rq. as_seriescyrkrlrnrs roto_dictzDataFrame.to_dictTTWrqcyrkrlrs rorzDataFrame.to_dictVsMPrqTcyrkrlrs rorzDataFrame.to_dictXs9>> 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']} rrw)rfrrrSrh)rnrrvalues rorzDataFrame.to_dict\s" #'"7"7"?"?'#@#%' CT\\%t{{\;;  $$,,y,AA s(A8c8|jj|S)akGet 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) (, ) )rfrow)rnrs rorz DataFrame.rowvs*$$((//rqc*t||g|i|S)avPipe 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 superrrnrrrrys rorzDataFrame.pipes4w|H6t6v66rqc$t||S)aDrop 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]] rrrrnrrys rorzDataFrame.drop_nullss0w!!00rqorder_byct|tr|gn|}|j|jj ||S)avInsert 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. 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]] rrrr{rfwith_row_indexrnrr order_by_s rorzDataFrame.with_row_indexsB.#-Xs";XJ ##  ! ! 0 0 0 J  rqct|S)aNGet 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}) )rrrnrys rorzDataFrame.schemasw~rqc t|S)aXGet 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 rorzDataFrame.collect_schemaw%''rqct|S)aGet column names. 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 rorzDataFrame.columnswrqFnamedcyrkrlrnrs rorzDataFrame.rowssORrqcyrkrlrs rorzDataFrame.rows sEHrqcyrkrlrs rorzDataFrame.rows rrqc:|jj|S)a6Returns 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)rfrrs rorzDataFrame.rowss"$$)))66rqc#K|jjD]!}|j||j#yw)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| └─────────────────────────┘ rwN)rf iter_columnsrSrh)rnrs rorzDataFrame.iter_columns"s=8++88: :F,,vT[[,9 9 :sAAr buffer_sizecyrkrlrnrrs ro iter_rowszDataFrame.iter_rowsAs%(rq)rcyrkrlrs rorzDataFrame.iter_rowsFs$'rqcyrkrlrs rorzDataFrame.iter_rowsKs @Crqic<|jj||S)aReturns 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)rfrrs rorzDataFrame.iter_rowsPs 4$$..U .TTrqc"t||i|S)a8Add 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 )rrrnrrrys rorzDataFrame.with_columnsls@w#U:k::rqc"t||i|S)uXSelect 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]] | └──────────────────┘ )rrrs rorzDataFrame.selects:w~u4 44rqc"t||S)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]] rrrnrrys rorzDataFrame.renames$w~g&&rqc"t||S)aGet 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 rrrnrrys rorzDataFrame.headsw|Arqc"t||S)uGet 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 | └──────────────────┘ )rrrs rorzDataFrame.tail&w|Arqrc4t|t|d|iS)aRemove 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 rrrrrnrrrys rorzDataFrame.drops&w|WW-=f==rqanykeepmaintain_orderrc|dvrddd|}t|t|tr|g}|j|jj ||||S)aJDrop 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. 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 >rlastnonefirst Expected rrrrrr)rrrr{rfunique)rnrrrrrs rorzDataFrame.uniquesrD 7 7<=WTFKCS/ ! fc "XF##  ! ! ( (T.8 )   rqc"t||i|S)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 (single!) boolean list. **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 )rr)rnrrrys rorzDataFrame.filter)sfw~z9[99rqdrop_null_keyscyrkrlrnrkeyss rogroup_byzDataFrame.group_by^rqcyrkrlrs rorzDataFrame.group_bycrrqcddlm}t|}td|Dr ||||Sddlm}ddlmddlm tfd|D}|rt|r d }t|t||D cgc]\}} | r|n||} }} |j| \} } td | Dsdd lm} d }| |||| |Scc} }w) aStart 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)rLc3<K|]}t|tywrkrrrs rorz%DataFrame.group_by..9z#s#9rrrExprr4c3:K|]}t|fywrkr)rrr r5s rorz%DataFrame.group_by..s%WjT6N&C%Wsz?drop_null_keys cannot be True when keys contains Expr or Seriesc3@K|]}|tjuywrkr ELEMENTWISErs rorz%DataFrame.group_by..BD48///B ComputeErrorHGroup by is not supported with keys that are not elementwise expressions)narwhals.group_byrLrrnarwhalsr narwhals.exprr rr5rrrr*rnarwhals.exceptionsr)rnrrrL flat_keysrkey_is_expr_or_seriesrris_expr_keysexpr_flat_keysrrr r5s @@rorzDataFrame.group_byhsr .DM 9y9 94>J J &* %%WY%W W c"78SC%c* *)4IJ 7Ac!f $  !: 9 95 ABEBB 8[ s# #t^NKK sCrc,t||g|||dS)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 | └──────────────────┘ rrrrnrrrrrys rorzDataFrame.sorts!Hw|BWWZJWWrqrc(t||||S)uxReturn 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. Returns: The dataframe with the `k` largest rows. 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 None 2 | | 5 c 1 | └──────────────────┘ rrrrnrrrrys rorzDataFrame.top_ksFw}Q2w}77rq_rightrrrc.t|||||||S)u|Join 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 rnrr rrrrrys ror zDataFrame.join s)Tw| sGh2f  rqrrrr rrrrrc 4t ||||||||||  S)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| └──────────────────────────────┘ r+rr rnrrrr rrrrrrys rorzDataFrame.join_asof;s8Nw !  rqc$|jS)u]Get 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_uniquerms ro is_duplicatedzDataFrame.is_duplicateds"   rqct|dk(S)a"Check 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)rrms rois_emptyzDataFrame.is_emptys4yA~rqcl|j|jj|jS)uUGet 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 | └───────────────┘ rw)rSrfr0rhrms ror0zDataFrame.is_uniques*"||D11;;=T[[|QQrqc|jj}|jj|jj }|j |S)ugCreate 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]] | └──────────────────┘ )rfrurr null_countr{)rnrr s ror6zDataFrame.null_countsN.##::<&&--cggi.B.B.DE##F++rqc<|jj||S)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)rfr)rnrr8s rorzDataFrame.items $$$))c&)AArqcT|j|jjS)z Create a copy of this DataFrame.)r{rfclonerms ror:zDataFrame.clones"##D$9$9$?$?$ABBrqc&t|||S)uTake 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)rnrrrys rorzDataFrame.gather_everys*w#a#77rq_)rvaluesaggregate_functionr sort_columns separatorc *|| d}t||d}t|tt|tr|gn|}t|tr|gn|}t|tr|gn|}|j |j j||||||S)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 rr=r>r?r@)rr UserWarningrrr{rfpivot) rnr rr=r>rr?r@rs rorCzDataFrame.pivot sn >emGCS/ !  %7  #{ +C(bTb'4&&%eS1u##  ! ! ' '#5)# (   rqc6|jjS)aConvert 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]] )rfrrms rorzDataFrame.to_arrowZs$$--//rq)fractionwith_replacementseedc^|j|jj||||S)u'Sample 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 | └──────────────────┘ )rrErFrG)r{rfsample)rnrrErFrGs rorIzDataFrame.sampleks<B##  ! ! ( (h9IPT )   rqvariablerrrr c*t|||||S)u$Unpivot 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| └────────────────────┘ rrr!rnr rrr rys ror!zDataFrame.unpivots%^wm   rqc$t||g|S)u?Explode 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 │ └─────┴─────┘ rr)rnrr*rys ror)zDataFrame.explodes8ww666rq)r,z.CompliantDataFrame[Any, Any, DataFrameT, Self]r.)r,ztype[Series[Any]])r,ztype[LazyFrame[Any]]rzrrxrgr,None)rerGrfIntoBackend[EagerAllowed]r,DataFrame[Any]rk)rjzMapping[str, Any]rzIntoSchema | Nonerfz IntoBackend[EagerAllowed] | Noner,rU)rjr\rz!IntoSchema | Sequence[str] | NonerfrTr,rU)r,r7)NN)rsrrq bool | Noner,r\r,r)ryz object | Noner,rA)rfzIntoBackend[LazyAllowed] | Nonerz Any | Noner,zLazyFrame[Any])r,rb)r,z pd.DataFrame)r,z pl.DataFrame)rrSr,rrzstr | Path | BytesIOr,rS)rzstr | Path | BytesIO | Noner,r?)r,r\)r,ztuple[int, int])rrr, Series[Any])b)rrZr,z int | float)rz-tuple[SingleIndexSelector, SingleColSelector]r,r)rz2str | tuple[MultiIndexSelector, SingleColSelector]r,rY)rzSingleIndexSelector | MultiIndexSelector | MultiColSelector | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, MultiColSelector]r,rA)ra SingleIndexSelector | SingleColSelector | MultiColSelector | MultiIndexSelector | tuple[SingleIndexSelector, SingleColSelector] | tuple[SingleIndexSelector, MultiColSelector] | tuple[MultiIndexSelector, SingleColSelector] | tuple[MultiIndexSelector, MultiColSelector]r,zSeries[Any] | Self | Any)rrr,r)r Literal[True]r,zdict[str, Series[Any]])rLiteral[False]r,zdict[str, list[Any]])rrr,z-dict[str, Series[Any]] | dict[str, list[Any]])rr7r,ztuple[Any, ...]r0r1r)rrrstr | Sequence[str] | Noner,rAr/r3)rr\r,zlist[tuple[Any, ...]])rr[r,zlist[dict[str, Any]])rrr,z,list[tuple[Any, ...]] | list[dict[str, Any]])r,zIterator[Series[Any]])rr\rr7r,zIterator[tuple[Any, ...]])rr[rr7r,zIterator[dict[str, Any]])rrrr7r,z4Iterator[tuple[Any, ...]] | Iterator[dict[str, Any]]r4r5r6rr:rrr,rA) rr2rr[rrrr^r,rAr8)rr-rr\r, GroupBy[Self])rr:rr[r,rb)rr-rrr,rbr9r<NrrrAr r2rrTrr2rr2rrr,rArrArr?rr?r r?rr2rr2rr2rrNrrr,rA)r,rY)r,rr,rA)r int | Noner8zint | str | Noner,rr=r>)r zstr | list[str]rr2r=r2r>zPivotAgg | NonerrVr?rr@rr,rA)r,zpa.Table) rrgrEz float | NonerFrrGrgr,rAr@rB)HrDrErF__doc__rMAINrKrGrHrprrSrVr\ classmethodrcrirlrnrrrvr|rr7rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr1r3r0r6rr:rrCrrIr!r) __classcell__rys@rorJrJs0#*,,H. %%@ &2)27P2 22h%)8 59 88"8 2 8  88t59DD2D + D  DDL/APN248Q# Q0Q Q  Qf3(1$1*66 @@5,2 ? + +W2?*ZZ F   :    l> :l> "l>\#47WW PP #'< < 6<<$(B B 6B4007477 7 7816" MQ  0J  8   (  .3RR HH WW %77 57&:>),(&(;>( "((:='%'47' !''14CC+.C =CC %UU36U =U8 ;3 ;DL ;  ;D535DL5 5>'("*BF>.*.+ $)$/3 + &+ ! +  + - +  + Z3:E3:VY3: 3:jUX2DR (:G  LQXL2XLDHXL XL|-2 $X $X$X* $X  $X  $XNTY#8#80#8;P#8 #8P&*# , +/+/, ,  #,  , ( , ), ,  , d##*.+/%)%/Q Q  Q  Q  Q (Q )Q  #Q #Q Q  Q h!& R&,6B(C86)-)-.2&*"M M & M ' M , M $M M M  M ^0&% "&!& % %  %  %  %  % R&*1 )-'! 1 "1 & 1  1  1  1 f77rqrJc eZdZdZed3dZd4dZed5dZd6dZd7dZ d8dZ d9 d:d Z d;d Z d<fd Z d9d=fd Z d> d?d Zed@fd Zd@fd ZedAfd Z dBfd Z dBfd ZdCfd ZdDdEfd ZdddFfdZ d9ddd dGdZ dHfd ZdIdZedd dJdZe dKd Zd!d dLd"Zd!d!d# dMfd$Zd!d% dNfd&Z dOddd'd( dPfd)Zddddddd*d'd+ dQfd,Z dRd-Z! d9dd.d/d0 dSfd1Z"dTfd2 Z#xZ$S)UrUaNarwhals LazyFrame, backed by a native lazyframe. Warning: This class is not meant to be instantiated directly - instead use [`narwhals.from_native`][] with a native object that is a lazy dataframe from one of the supported backend (e.g. polars.LazyFrame, dask_expr._collection.DataFrame): ```py narwhals.from_native(native_lazyframe) ``` c|jSrkrMrms rorpzLazyFrame._compliantrNrqcddlm}ddlm}t ||r d}t |t ||t frst ||rF|jjr d}t||jjr d}t||jj|dStjt|) Nrr r4zABinary operations between Series and LazyFrame are not supported.aOrder-dependent expressions are not supported for use in LazyFrame. Hint: To make the expression valid, use `.over` with `order_by` specified. For example, if you wrote `nw.col('price').cum_sum()` and you have a column `'date'` which orders your data, then replace: nw.col('price').cum_sum() with: nw.col('price').cum_sum().over(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()) Fr~)rr rr5rrr _metadatan_orderable_opsr/ is_filtrationrurPr.rQr)rnrr r5rs rorzLazyFrame._extract_compliants&* c6 "UCC. cD#; '#t$==00b044==..M044..0@@QV@W W"44T#Y??rqctSrk)rJrms rorbzLazyFrame._dataframe rWrqc||_|t|r|j|_ydt |}t |)NzVExpected Polars LazyFrame or an object that implements `__narwhals_lazyframe__`, got: )rhr!__narwhals_lazyframe__rfrrZr[s ror\zLazyFrame.__init__ sD  !" %$&$=$=$?D !jkoprksjtuC % %rqcRtd|jjS)NzNarwhals LazyFramerurms rorvzLazyFrame.__repr__% rwrqcd}t|)Nz%Slicing is not supported on LazyFrame)r)rnrrs rorzLazyFrame.__getitem__( s5nrqNc |jj}||j|di|dStj|}t |r|j||fi|dSdt td|d}t|)u 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]] | └──────────────────┘ rrwz-Unsupported `backend` value. Expected one of z or None, got: rrk) rfcollectrbrr`rrrr)rnrfrry eager_backendrs roryzLazyFrame.collect, sx''// ???7#:6#:&?I I&33G<  /??7=#CF#C6?R R>xH]?^>__no|n}}~orqct|dS)u~Convert 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_throughr6rms ror7zLazyFrame.to_nativeq s"EBBrqc*t||g|i|S)uPipe 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 rorzLazyFrame.pipe s6w|H6t6v66rqc$t||S)uhDrop 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 │ | |└───────┴───────┘ | └──────────────────┘ rrrs rorzLazyFrame.drop_nulls s6w!!00rqct|tr|gn|}|j|jj ||S)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. 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]] | └──────────────────┘ rrrs rorzLazyFrame.with_row_index sCP#-Xs";XJ ##  ! ! 0 0 0 J  rqc|jjtjurd}t |t t |S)aeGet 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}) zResolving the schema of a LazyFrame is a potentially expensive operation. Use `LazyFrame.collect_schema()` to get the schema without this warning.)rfrKrV1rr0rr)rnrrys rorzLazyFrame.schema s?  ) ) ;[  #1 2w~rqc t|S)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}) rrs rorzLazyFrame.collect_schema rrqct|S)aGet column names. 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 rorzLazyFrame.columns rrqcD|s|s d}t|t||i|S)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)rrrrnrrrrys rorzLazyFrame.with_columns s/H[TCS/ !w#U:k::rqcD|s|s d}t|t||i|S)u1Select 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)rrrrs rorzLazyFrame.selectA s.D[NCS/ !w~u4 44rqc"t||S)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 │| |└───────┴──────────────┘| └────────────────────────┘ rrs rorzLazyFrame.renameh s2w~g&&rqc"t||S)uGet `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 | └──────────────────┘ rrs rorzLazyFrame.head rrqTrc4t|t|d|iS)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 │ └───────┘ rrrs rorzLazyFrame.drop s6w|WW-=f==rqr)rrc|dvrddd|}t||dvr|s d}t|t|tr|g}|j |j j |||S)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. 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 │ | |└───────┴───────┘ | └──────────────────┘ >rrrrrrr>rrznarwhals.LazyFrame makes no assumptions about row order, so only 'first' and 'last' are only supported if `order_by` is passed.)rrr)rr/rrr{rfr)rnrrrrs rorzLazyFrame.unique sJ 7 7<=WTFKCS/ ! $ $XQ (, , fc "XF##  ! ! ( (TH ( U  rqct|dk(r"t|dtr|s d}t|t ||i|S)uj Filter the rows in the LazyFrame based on a predicate expression. The original order of the remaining rows is preserved. Arguments: *predicates: Expression that evaluates to a boolean Series. Can also be a (single!) boolean list. **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 │ └───────┴───────┴─────────┘ rrzX`LazyFrame.filter` is not supported with Python boolean masks - use expressions instead.)rr%rrrr)rnrrrrys rorzLazyFrame.filter sDX  Oq Z 1 t%D[lCC. w~z9[99rqc:|jj|y)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)rf sink_parquetrs rorzLazyFrame.sink_parquet< s **40rq.rcyrkrlrs rorzLazyFrame.group_byN  rqcyrkrlrs rorzLazyFrame.group_byS rrqFcddlm}t|}td|Dr ||||Sddlm}ddlmtfd|D}|rt|r d}t|t||D cgc]\}} | r|n||} }} |j| \} } td | Dsdd l m} d }| |||| |Scc} }w) uStart 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)rMc3<K|]}t|tywrkrrs rorz%LazyFrame.group_by.. r rrrr c36K|]}t|ywrkr )rrr s rorz%LazyFrame.group_by.. sCAJq$/Csz5drop_null_keys cannot be True when keys contains Exprc3@K|]}|tjuywrkrrs rorz%LazyFrame.group_by.. rrrr)rrMrrrrrr rrrr*rrr)rnrrrMrr key_is_exprrrrrrrrr s @rorzLazyFrame.group_byX sR 2DM 9y9 9tY~N N &CCC c+.IC%c* *8B)[7Y )3GAc!f $  !: 9 95 ABEBB 8[ s# #4OO s9Crc,t||g|||dS)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 │| |└───────┴──────────────┴─────────┘| └──────────────────────────────────┘ rr r!s rorzLazyFrame.sort s!Vw|BWWZJWWrqrc(t||||S)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. Returns: The LazyFrame with the `k` largest rows. 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 │| |└─────────┴───────┘| └───────────────────┘ rr#r$s rorzLazyFrame.top_k sPw}Q2w}77rqr%r&c.t|||||||S)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 │| |└───────┴─────────┴─────────┘| └─────────────────────────────┘ r(r)r*s ror zLazyFrame.join s)fw| sGh2f  rqrr+c 4t ||||||||||  S)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 │ └─────────────────────┴────────────┴──────┘ r+r-r.s rorzLazyFrame.join_asof. s8Tw !  rqc|S)zRestrict available API methods to lazy-only ones. This is a no-op, and exists only for compatibility with `DataFrame.lazy`. rlrms rorzLazyFrame.lazy s  rqrJrrKc*t|||||S)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 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 │ └─────────┴──────────┴───────┘ rrMrNs ror!zLazyFrame.unpivot s%dwm   rqc$t||g|S)uExplode 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 │ └─────────┴───────┘ rPrQs ror)zLazyFrame.explode s@ww666rq)r,z)CompliantLazyFrame[Any, LazyFrameT, Self]r.)r,ztype[DataFrame[Any]]rRrW)rz str | slicer,r rk)rfz+IntoBackend[Polars | Pandas | Arrow] | Nonerrr,rU)r,rar0r1r])rrrrCr,rAr/r3r4r5r_r6ra)rr2rr[rr^r,rAr8rX)rr-rr\r,LazyGroupBy[Self])rr:rr[r,r)rr-rrr,rr9r<rcrdrerfr@rB)%rDrErFrhrHrprrbr\rvrryr7rrrrrrrrrrrrrrrrrrr rrr!r)rkrls@rorUrUs %%!@F&P FJCBCUXC CJC(7477 7 7:1<"+ + 0C+ + Z$ (  ';3';DL'; ';R%53%5DL%5 %5N'6*BF>>*.2 $)/3 2 &2 ! 2 - 2  2 hQ:EQ:VYQ: Q:f1$UX 2 DR    ( :G   LQFP2FPDHFP FPX-2 +X +X+X* +X  +X  +X\TY(8(80(8;P(8 (8Z&*# 5 +/+/5 5  #5  5 ( 5 )5 5  5 v##*.+/%)%/T T  T  T  T (T )T  #T #T T  T l&*4 )-'! 4 "4 & 4  4  4  4 l 7 7rqrU) __future__rabcr itertoolsrtypingrrrr r r r r rrnarwhals._exceptionsrnarwhals._expression_parsingrrrrnarwhals._typingrrrrnarwhals._utilsrrrrrrrr r!r"r#r$r%r&r'r(r)r*narwhals.dependenciesr+r,rr-r.r/r0rr1r2narwhals.schemar3rr5narwhals.translater7collections.abcr8r9r:r;ior<pathlibr=typesr>pandaspdpolarsplpyarrowpatyping_extensionsr?r@rArBnarwhals._compliantrCrDnarwhals._compliant.typingrErFnarwhals._translaterGrHrIrJrKrrLrMnarwhals.typingrNrOrPrQrRrSrTrU_MultiColSelectorrV_MultiIndexSelectorrWrXrYrZr[r\r]r^rGr_rarbrcrerJrUrlrqrorsN"   / TS(F F""(EE IIJN2OO6$ 4BJ  ); / \ 9 \ 9  CL>)> BIBTW TWn b7 *%b7J9}7 *%}7rq