ó Lpˆjx,ãó¨•%SSKJr SSKrSSKrSSKJrJrJr SSKJ r J r SSK J r J r JrJrJr SSKJrJrJrJrJrJrJrJrJrJr SSKJrJrJrJ r SSK!J"r" SS K#J$r$ SS K%J&r& SS K'J(r(J)r) \ (a]SS K*J+r+ SS KJ,r, SSK-J.r.J/r/ SSK0J1r1J2r2J3r3 SSK4J5r5 SSK6J7r7J8r8J9r9J:r: SSK;JJ?r? SSK@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJ SrKS\LS'SS.SRSjjrMSSSTSjjrNSSSTSjjrO\"SS9SSSSS.SUS jjj5rPSVS!jrQSSSWS"jjrRSSSXS#jjrSSYS$jrTSZS%jrUS[S&jrVS[S'jrWS\S(jrXS)S*.S]S+jjrYS)S*.S^S,jjrZS_S-jr[S`S.jr\SaS/jr]SaS0jr^SbS1jr_ScS2jr`ScS3jraSdS4jrbSdS5jrcSdS6jrdSdS7jreSdS8jrfSeS9jrgSfSgS:jjrhS;S<.ShS=jjriSiS>jrjSiS?jrkSiS@jrl"SASB5rm"SCSD\$5rnSjSEjroSkSFjrpSSSlSGjjrqSkSHjrrSiSIjrsSJSKSL.SmSMjjrtSnSNjruSoSOjrvSpSPjrwSqSQjrxg)ré)Ú annotationsN)ÚIterableÚMappingÚSequence)Ú TYPE_CHECKINGÚAny)ÚExprKindÚExprNodeÚ_parse_into_exprÚis_exprÚ is_series) ÚImplementationÚVersionÚdeprecate_native_namespaceÚflattenÚis_eager_allowedÚis_nested_literalÚis_sequence_ofÚnormalize_pathÚsupports_arrow_c_streamÚvalidate_laziness)Úis_narwhals_seriesÚis_numpy_arrayÚis_numpy_array_2dÚis_pyarrow_table)ÚInvalidOperationError)ÚExpr)ÚSchema)Ú from_nativeÚ to_native)Ú ModuleType)Ú TypeAlias)ÚSelfÚTypeIs)ÚNativeDataFrameÚNativeLazyFrameÚ NativeSeries)ÚIntoArrowTable)ÚBackendÚ EagerAllowedÚ IntoBackendÚ PluginName)Ú DataFrameÚ LazyFrame)ÚSeries) Ú ConcatMethodÚCorrelationMethodÚ FileSourceÚFrameTÚ IntoDTypeÚIntoExprÚ IntoSchemaÚNonNestedLiteralÚ PythonLiteralÚ_2DArrayú!IntoSchema | Sequence[str] | Noner"Ú _IntoSchemaÚvertical©Úhowcón•SSKJn U(d Sn[U5e[U5n[ U5 US;a Sn[ U5eUSnU"U5(aUS:Xa Sn[ U5eUR5nURURUVs/sHofRPM snUS95$s snf) uÿ Concatenate multiple DataFrames, LazyFrames into a single entity. Arguments: items: DataFrames, LazyFrames to concatenate. how: concatenating strategy - vertical: Concatenate vertically. Column names must match. - horizontal: Concatenate horizontally. If lengths don't match, then missing rows are filled with null values. This is only supported when all inputs are (eager) DataFrames. - diagonal: Finds a union between the column schemas and fills missing column values with null. Raises: TypeError: The items to concatenate should either all be eager, or all lazy Examples: Let's take an example of vertical concatenation: >>> import pandas as pd >>> import polars as pl >>> import pyarrow as pa >>> import narwhals as nw Let's look at one case a for vertical concatenation (pandas backed): >>> df_pd_1 = nw.from_native(pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})) >>> df_pd_2 = nw.from_native(pd.DataFrame({"a": [5, 2], "b": [1, 4]})) >>> nw.concat([df_pd_1, df_pd_2], how="vertical") ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 4 | | 1 2 5 | | 2 3 6 | | 0 5 1 | | 1 2 4 | └──────────────────┘ Let's look at one case a for horizontal concatenation (polars backed): >>> df_pl_1 = nw.from_native(pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})) >>> df_pl_2 = nw.from_native(pl.DataFrame({"c": [5, 2], "d": [1, 4]})) >>> nw.concat([df_pl_1, df_pl_2], how="horizontal") ┌───────────────────────────┠| Narwhals DataFrame | |---------------------------| |shape: (3, 4) | |┌─────┬─────┬──────┬──────â”| |│ a ┆ b ┆ c ┆ d │| |│ --- ┆ --- ┆ --- ┆ --- │| |│ i64 ┆ i64 ┆ i64 ┆ i64 │| |â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡| |│ 1 ┆ 4 ┆ 5 ┆ 1 │| |│ 2 ┆ 5 ┆ 2 ┆ 4 │| |│ 3 ┆ 6 ┆ null ┆ null │| |└─────┴─────┴──────┴──────┘| └───────────────────────────┘ Let's look at one case a for diagonal concatenation (pyarrow backed): >>> df_pa_1 = nw.from_native(pa.table({"a": [1, 2], "b": [3.5, 4.5]})) >>> df_pa_2 = nw.from_native(pa.table({"a": [3, 4], "z": ["x", "y"]})) >>> nw.concat([df_pa_1, df_pa_2], how="diagonal") ┌──────────────────────────┠| Narwhals DataFrame | |--------------------------| |pyarrow.Table | |a: int64 | |b: double | |z: string | |---- | |a: [[1,2],[3,4]] | |b: [[3.5,4.5],[null,null]]| |z: [[null,null],["x","y"]]| └──────────────────────────┘ r)Úis_narwhals_lazyframezNo items to concatenate.>Údiagonalr<Ú horizontalzDOnly vertical, horizontal and diagonal concatenations are supported.rBzdHorizontal concatenation is not supported for LazyFrames. Hint: you may want to use `join` instead.r=) Únarwhals.dependenciesr@Ú ValueErrorÚtuplerÚNotImplementedErrorrÚ__narwhals_namespace__Ú_with_compliantÚconcatÚ_compliant_frame)Úitemsr>r@ÚmsgÚ first_itemÚplxÚdfs ÚN/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/functions.pyrIrIAs½€õ^<æ Ø(ˆÜ˜‹oÐÜ %‹L€EÜeÔØ Ð8Ó8ØTˆÜ! #Ó&Ð&Øq‘€JÙ˜Z×(Ñ(¨S°LÓ-@ð 8ð ô$ CÓ(Ð(Ø × +Ñ +Ó -€CØ × %Ñ %Ø ‰ ±%Ó8²%¨B×'Ô'±%Ñ8¸cˆ ÐBó ðùÚ8sÂB2 có•[XX#S9$)uŸInstantiate Narwhals Series from iterable (e.g. list or array). Arguments: name: Name of resulting Series. values: Values of make Series from. dtype: (Narwhals) dtype. If not provided, the native library may auto-infer it from `values`. backend: specifies which eager backend instantiate to. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> values = [4, 1, 2, 3] >>> nw.new_series(name="a", values=values, dtype=nw.Int32, backend=pd) ┌─────────────────────┠| Narwhals Series | |---------------------| |0 4 | |1 1 | |2 2 | |3 3 | |Name: a, dtype: int32| └─────────────────────┘ ©Úbackend)Ú_new_series_impl)ÚnameÚvaluesÚdtyperSs rPÚ new_seriesrX§s€ôN ˜D¨%Ñ AÐAócó •[R"U5n[U5(a][RR RU5R nURRXXRS9nUR5$U[RLa<UR5nURXU5n[USS9RU5$USUS3n [!U 5e![an Sn [U 5U eSn A ff=f)N)rUÚcontextrWT)Ú series_onlyzDUnknown namespace is expected to implement `new_series` constructor.zÝ support in Narwhals is lazy-only, but `new_series` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.new_series('a', [1,2,3], backend='pyarrow').to_frame().lazy('ú'))rÚ from_backendrrÚMAINÚ namespaceÚ compliantÚ_seriesÚ from_iterableÚ to_narwhalsÚUNKNOWNÚto_native_namespacerXrÚaliasÚAttributeErrorrD) rUrVrWrSÚimplementationÚnsÚseriesÚ_native_namespaceÚ native_seriesÚerLs rPrTrTÑs €ô$×0Ò0°Ó9€Nܘ×'Ñ'Ü \‰\× #Ñ #× 0Ñ 0°Ó @× JÑ JˆØ—‘×)Ñ)¨&ÀRÐ)ÐUˆØ×!Ñ!Ó#Ð#Øœ×/Ñ/Ò/Ø*×>Ñ>Ó@Ðð -Ø*;×*FÑ*Fؘeó+ˆMô˜}¸$Ñ?×EÑEÀdÓKÐ Kð Ð ðOàO]ÐN^Ð^`ð bðô S‹/Ðøôó -ØXˆCÜ  Ó%¨1Ð ,ûð -úsÂ(*C&Ã& DÃ0C>Ã>Dz1.26.0)Ú warn_version)rSÚnative_namespacecóÚ•Uc [U5upUb [U5OSnU(aTU(aM[UR55R UR55=n(aSU3n[ U5e[ R"U5n[U5(a[[RRRU5RnURRXUS9R5$U[ R La*UR#5nURXS9n ['U SS9$USUS 3n[)U5e![$an Sn[%U5U eSn A ff=f) 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`. native_namespace: deprecated, same as `backend`. Examples: >>> import pandas as pd >>> import narwhals as nw >>> data = {"c": [5, 2], "d": [1, 4]} >>> nw.from_dict(data, backend="pandas") ┌──────────────────┠|Narwhals DataFrame| |------------------| | c d | | 0 5 1 | | 1 2 4 | └──────────────────┘ NzIKeys in `schema` and `data` are expected to match, found unmatched keys: )Úschemar[©rrz@Unknown namespace is expected to implement `from_dict` function.T©Ú eager_onlyzÑ support in Narwhals is lazy-only, but `from_dict` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.from_dict({'a': [1, 2]}, backend='pyarrow').lazy('r])Ú_from_dict_no_backendÚdictÚsetÚkeysÚsymmetric_differencerrr^rrr_r`raÚ _dataframeÚ from_dictrdrerfrhrrD) ÚdatarrrSrpÚdiffrLrirjrlÚ native_framerns rPr|r|ïsd€ð`Ü-¨dÓ3‰ ˆØ#Ñ/ŒT&Œ\°T€FÞ –$¤C¨¯ © « Ó$6×$KÑ$KÈDÏIÉIËKÓ$XÐX˜DÕXØYÐZ^ÐY_Ð`ˆÜ# CÓ(Ð(Ü#×0Ò0°Ó9€Nܘ×'Ñ'Ü \‰\× #Ñ #× 0Ñ 0°Ó @× JÑ JˆØ}‰}×&Ñ& tÀBÐ&ÐG×SÑSÓUÐUØœ×/Ñ/Ò/Ø*×>Ñ>Ó@Ðð -ð->×,GÑ,GØð-Hð-ˆLô ˜<°DÑ9Ð9à Ð ðFàFTÐEUÐUWð Yðô S‹/Ðøôó -ØTˆCÜ  Ó%¨1Ð ,ûð -úsÄ!E Å E*ÅE%Å%E*c óú•UR5H%n[U5(dMUR5n O Sn[U5eUR 5VVs0sHupEU[ USS9_M nnnX4$s snnf)NzgCalling `from_dict` without `backend` is only supported if all input values are already Narwhals SeriesT)Ú pass_through)rVrÚ__native_namespace__Ú TypeErrorrKr )r}ÚvalrprLÚkeyÚvalues rPrvrv=sz€ð{‰{Ž}ˆÜ ˜c× "Ó "Ø"×7Ñ7Ó9Ð Ù ñð xˆÜ˜‹nÐØGKÇzÁzÄ|Ô TÂ|¹¸ˆC”˜5¨tÑ4Ò 4Á|€DÑ TØ Ð !Ð!ùó UsÁA7cóR•[RRRXUS9$)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 │| |└───────┴────────┴───────┘| └──────────────────────────┘ rR)rr_Ú dataframeÚ from_dicts)r}rrrSs rPr‰r‰Ks%€ô| <‰<× !Ñ !× ,Ñ ,¨TÀ7Ð ,Ð KÐKrYcó¦•[U5(d Sn[U5e[U5(dS[U5S3n[ U5eUb [ U[ 5(d [U5n[R"U5n[U5(aR[RRRU5RnURX5R!5$U[R"La*UR%5nURXS9n[)USS9$US US 3n[U5e![&anSn['U5UeSnAff=f) u¹Construct a DataFrame from a NumPy ndarray. Notes: Only row orientation is currently supported. For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Two-dimensional data represented as a NumPy ndarray. schema: The DataFrame schema as Schema, dict of {name: type}, an iterable of (name, type) tuples, or a sequence of str. backend: specifies which eager backend instantiate to. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. Examples: >>> import numpy as np >>> import pyarrow as pa >>> import narwhals as nw >>> >>> arr = np.array([[5, 2, 1], [1, 4, 3]]) >>> schema = {"c": nw.Int16(), "d": nw.Float32(), "e": nw.Int8()} >>> nw.from_numpy(arr, schema=schema, backend="pyarrow") ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | c: int16 | | d: float | | e: int8 | | ---- | | c: [[5,1]] | | d: [[2,4]] | | e: [[1,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 Ú.NrszAUnknown namespace is expected to implement `from_numpy` function.TrtzÉ support in Narwhals is lazy-only, but `from_numpy` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.from_numpy(arr, backend='pyarrow').lazy('r])rrDÚ_is_into_schemaÚtyperƒrÚstrrrr^rrr_r`raÚ from_numpyrdrerfrhr) r}rrrSrLrirjrlrrns rPrrŒsW€ô` ˜T× "Ñ "Ø9ˆÜ˜‹oÐÜ ˜6× "Ñ "ð 䘓<. ð #ð ô ˜‹nÐØ ‰Nœn¨V´S×9Ñ9ܘ“ˆÜ#×0Ò0°Ó9€Nܘ×'Ñ'Ü \‰\× #Ñ #× 0Ñ 0°Ó @× JÑ JˆØ}‰}˜TÓ*×6Ñ6Ó8Ð8Øœ×/Ñ/Ò/Ø*×>Ñ>Ó@Ðð -ð->×,HÑ,HØð-Ið-ˆLô ˜<°DÑ9Ð9à Ð ð;à;IÐ:JÈ"ð Nðô S‹/Ðøôó -ØUˆCÜ  Ó%¨1Ð ,ûð -úsÄD3Ä3 EÄ=E Å Ecóª•USL=(dI [U[[45=(d, [U[5=(a [U[5(+$©N)Ú isinstancerrrrŽ)Úobjs rPrŒrŒàsB€à ˆtˆ ÷ DÜ cœG¤VÐ,Ó -÷ Dä sœHÓ %× B¬j¸¼cÓ.BÔ*BðrYcóZ•[U5(d*[U5(dS[U5S3n[U5e[R "U5n[ U5(aZ[RRR U5RnURRXS9R5$U[RLa,UR5nUR!U5n[%USS9$USUS 3n['U5e!["anSn[#U5UeSnAff=f) 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.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)r[zuUnknown namespace is expected to implement `DataFrame` class which accepts object which supports PyCapsule Interface.NTrtzÈ support in Narwhals is lazy-only, but `from_arrow` is an eager-only function. Hint: you may want to use an eager backend and then call `.lazy`, e.g.: nw.from_arrow(df, backend='pyarrow').lazy('r])rrrrƒrr^rrr_r`rar{Ú from_arrowrdrerfr-rhrrD)rrSrLrirjrlÚnativerns rPr•r•ès*€ôJ $ L× 1Ñ 1Ô5EÀl×5SÑ5SØ%¤d¨<Ó&8Ð%9Ð9^Ð_ˆÜ˜‹nÐÜ#×0Ò0°Ó9€Nܘ×'Ñ'Ü \‰\× #Ñ #× 0Ñ 0°Ó @× JÑ JˆØ}‰}×'Ñ'¨ Ð'ÐA×MÑMÓOÐOØœ×/Ñ/Ò/Ø*×>Ñ>Ó@Ðð -ð'8×&AÑ&AÀ,Ó&OˆFô˜6¨dÑ3Ð3à Ð ð:à:HÐ9IÈð Mðô S‹/Ðøôó -ðJˆCÜ  Ó%¨1Ð ,ûð -úsÃD Ä D*ÄD%Ä%D*có°•[RRSS5nSU4S[R4S[R"544n[ U5$)zƒSystem information. Returns system and Python version information Copied from sklearn Returns: Dictionary with system info. Ú Ú ÚpythonÚ executableÚmachine)ÚsysÚversionÚreplacer›Úplatformrw)ršÚblobs rPÚ _get_sys_infor¢&sT€ô[‰[× Ñ   sÓ +€Fð 6ÐØ ”s—~‘~Ð&Ø ”H×%Ò%Ó'Ð(ð €Dô ‹:ÐrYcó~^ •SSKJn Sn[RnSS1m [ U 4Sj/UQUQ755n[ R US5nU"5HdnURR5URpvXd;aXtU'M3UH+nXH(aMURU5(dM&XtU' Mb Mf U$)alOverview of the installed version of main dependencies. This function does not import the modules to collect the version numbers but instead relies on standard Python package metadata. Returns version information on relevant Python libraries This function and show_versions were copied from sklearn and adapted Returns: Mapping from dependency to version. r)Ú distributions)ÚnarwhalsÚnumpyÚPYSPARK_CONNECTrec3óR># •UHoT;dM UR5v• M g7fr‘)Úlower)Ú.0rUÚexcludes €rPÚ Ú!_get_deps_info..Ms$øé€ðÚ!>˜ÈgÑBU‹ ˆ ‰ ˆ Ò!>ùsƒ ''Ú) Úimportlib.metadatar¤rÚ_member_names_rErwÚfromkeysrUr©ržÚ startswith) r¤Ú extra_namesÚ member_namesÚ target_namesÚresultÚdistÚ dist_nameÚ dist_versionÚtargetr«s @rPÚ_get_deps_infor»;s¾ø€õ1à'€KÜ!×0Ñ0€LØ  )Ð,€GÜôØ!> ;Ð!>°Ò!>óó€Lô]‰]˜<¨Ó ,€Fá–ˆØ"&§)¡)§/¡/Ó"3°T·\±\<à Ó Ø ,9Ó ã&Ø—~‘~¨)×*>Ñ*>Ø÷+ó+ð&2˜6‘NÚó 'ñ  ð €MrYcó•[5n[5n[S5 UR5Hup#[USSU35 M [S5 UR5Hup#[USSU35 M g)z„Print useful debugging information. Examples: >>> from narwhals import show_versions >>> show_versions() # doctest: +SKIP z System:z>10z: z Python dependencies:z>13N)r¢r»ÚprintrK)Úsys_infoÚ deps_infoÚkÚstats rPÚ show_versionsrÂbsv€ô‹€HÜÓ €Iä ˆ+ÔØ—>‘>Ö#‰ˆÜ 3r˜$˜Ð Ö!ñ$ô Ð "Ô#Ø—?‘?Ö$‰ˆÜ 3r˜$˜Ð Ö!ò%rYÚ,©Ú separatorc ó•[R"U5n[U5(aa[RR RU5R nUR"[U54SU0UD6nUR5$U[RLa/UR5nUR"S SU0UD6n[USS9$SUSUS US 3n [U 5e![an Sn [U 5U eSn A ff=f) u>Read a CSV file into a DataFrame. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. separator: Single byte character to use as separator in the file. kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.read_csv('file.csv', backend='pandas', engine='pyarrow')`. Examples: >>> import narwhals as nw >>> nw.read_csv("file.csv", backend="pandas") # doctest:+SKIP ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 4 | | 1 2 5 | └──────────────────┘ rÅÚsourcez?Unknown namespace is expected to implement `read_csv` function.NTrtúExpected eager backend, found z . Hint: use nw.scan_csv(source=ú , backend=Ú)©)rr^rrr_r`raÚread_csvrrdrerfrhrrD) rÇrSrÅÚkwargsÚimplrjÚframerprrnrLs rPrÌrÌus€ôD × &Ò & wÓ /€Dܘ×ÑÜ \‰\× #Ñ #× 0Ñ 0°Ó 6× @Ñ @ˆØ— ’ œN¨6Ó2ÑR¸iÐRÈ6ÑRˆØ× Ñ Ó"Ð"Ø Œ~×%Ñ%Ò%Ø×3Ñ3Ó5Ðð -ð-=×,EÒ,Eñ-Øð-Ø!'ñ-ˆLô ˜<°DÑ9Ð9à (¨¨ð/(Ø(. x¨z¸'¸À!ð Eðô S‹/Ðøôó -ØSˆCÜ  Ó%¨1Ð ,ûð -úsÂ,C!Ã! C>Ã+C9Ã9C>c óò•[R"U5nU[RLa>UR5nUR"SSU0UD6n[ U5R5$[RRRU5Rn U R"[U54SU0UD6n U R5R5n U $![ anSn[ U5UeSnAff=f)uFLazily read from a CSV file. For the libraries that do not support lazy dataframes, the function reads a csv file eagerly and then converts the resulting dataframe to a lazyframe. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. separator: Single byte character to use as separator in the file. kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.scan_csv('file.csv', backend=pd, engine='pyarrow')`. Examples: >>> import duckdb >>> import narwhals as nw >>> >>> nw.scan_csv("file.csv", backend="duckdb").to_native() # doctest:+SKIP ┌─────────┬───────┠│ a │ b │ │ varchar │ int32 │ ├─────────┼───────┤ │ x │ 1 │ │ y │ 2 │ │ z │ 3 │ └─────────┴───────┘ rÇz?Unknown namespace is expected to implement `scan_csv` function.NrÅrË)rr^rerfÚscan_csvrhrÚlazyrr_r`rarrd) rÇrSrÅrÍrÎrprrnrLrjrÏr¶s rPrÑrѯsí€ôP × &Ò & wÓ /€DØ Œ~×%Ñ%Ò%Ø×3Ñ3Ó5Ðð -ð?O×>WÒ>Wñ?Øð?Ø!'ñ?ˆLô ˜<Ó(×-Ñ-Ó/Ð/Ü ‰× Ñ × ,Ñ ,¨TÓ 2× <Ñ <€BØ KŠKœ vÓ.Ñ N¸)Ð NÀvÑ N€EØ"×.Ñ.Ó0×5Ñ5Ó7€FØ €Møôó -ØSˆCÜ  Ó%¨1Ð ,ûð -ús»Cà C6Ã#C1Ã1C6c óþ•[R"U5n[U5(a_[RR RU5R nUR"[U540UD6nUR5$U[RLa/UR5nUR"S SU0UD6n[USS9$SUSUSUS 3n [U 5e![anSn [U 5UeSnAff=f) u€Read into a DataFrame from a parquet file. Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.read_parquet('file.parquet', backend=pd, engine='pyarrow')`. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> nw.read_parquet("file.parquet", backend="pyarrow") # doctest:+SKIP ┌──────────────────┠|Narwhals DataFrame| |------------------| |pyarrow.Table | |a: int64 | |c: double | |---- | |a: [[1,2]] | |c: [[0.2,0.1]] | └──────────────────┘ rÇzCUnknown namespace is expected to implement `read_parquet` function.NTrtrÈz$. Hint: use nw.scan_parquet(source=rÉrÊrË)rr^rrr_r`raÚ read_parquetrrdrerfrhrrD) rÇrSrÍrÎrjrÏrprrnrLs rPrÔrÔês€ôD × &Ò & wÓ /€Dܘ×ÑÜ \‰\× #Ñ #× 0Ñ 0°Ó 6× @Ñ @ˆØ—’¤¨vÓ 6ÑA¸&ÑAˆØ× Ñ Ó"Ð"Ø Œ~×%Ñ%Ò%Ø×3Ñ3Ó5Ðð -ð-=×,IÒ,Iñ-Øð-Ø!'ñ-ˆLô ˜<°DÑ9Ð9à (¨¨ð/,Ø,2¨8°:¸g¸YÀað Iðô S‹/Ðøôó -ØWˆCÜ  Ó%¨1Ð ,ûð -úsÂ*Cà C<Ã)C7Ã7C<c óî•[R"U5nU[RLa>UR5nUR"SSU0UD6n[ U5R5$[RRRU5RnUR"[U540UD6n U R5R5n U $![ anSn[ U5UeSnAff=f)uFLazily read from a parquet file. For the libraries that do not support lazy dataframes, the function reads a parquet file eagerly and then converts the resulting dataframe to a lazyframe. Note: Spark like backends require a session object to be passed in `kwargs`. For instance: ```py import narwhals as nw from sqlframe.duckdb import DuckDBSession nw.scan_parquet(source, backend="sqlframe", session=DuckDBSession()) ``` Arguments: source: Path to a file. backend: The eager backend for DataFrame creation. `backend` can be specified in various ways - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN`, `CUDF`, `PYSPARK` or `SQLFRAME`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"`, `"cudf"`, `"pyspark"` or `"sqlframe"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin`, `cudf`, `pyspark.sql` or `sqlframe`. kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.scan_parquet('file.parquet', backend=pd, engine='pyarrow')`. Examples: >>> import dask.dataframe as dd >>> from sqlframe.duckdb import DuckDBSession >>> import narwhals as nw >>> >>> nw.scan_parquet("file.parquet", backend="dask").collect() # doctest:+SKIP ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 1 4 | | 1 2 5 | └──────────────────┘ >>> nw.scan_parquet( ... "file.parquet", backend="sqlframe", session=DuckDBSession() ... ).collect() # doctest:+SKIP ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | a: int64 | | b: int64 | | ---- | | a: [[1,2]] | | b: [[4,5]] | └──────────────────┘ rÇzCUnknown namespace is expected to implement `scan_parquet` function.NrË)rr^rerfÚ scan_parquetrhrrÒrr_r`rarrd) rÇrSrÍrÎrprrnrLrjrÏr¶s rPrÖrÖ$sâ€ô| × &Ò & wÓ /€DØ Œ~×%Ñ%Ò%Ø×3Ñ3Ó5Ðð -ð!×-Ò-ÑF°VÐF¸vÑFð ô ˜<Ó(×-Ñ-Ó/Ð/Ü ‰× Ñ × ,Ñ ,¨TÓ 2× <Ñ <€BØ OŠOœN¨6Ó2Ñ =°fÑ =€EØ"×.Ñ.Ó0×5Ñ5Ó7€FØ €Møôó -ØWˆCÜ  Ó%¨1Ð ,ûð -ús»Cà C4Ã!C/Ã/C4có\•[U5n[[[RSUS95$)ugCreates an expression that references one or more columns by their name(s). Arguments: names: Name(s) of the columns to use. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]}) >>> nw.from_native(df_native).select(nw.col("a", "b") * nw.col("b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (2, 2) | | ┌─────┬─────┠| | │ a ┆ b │ | | │ --- ┆ --- │ | | │ i64 ┆ i64 │ | | â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ | | │ 3 ┆ 9 │ | | │ 8 ┆ 16 │ | | └─────┴─────┘ | └──────────────────┘ Úcol©Únames)rrr r ÚCOL)rÚÚ flat_namess rPrØrØus%€ô4˜“€JÜ ”œŸ™ u°JÑ?Ó @Ð@rYc ój•[[[RS[ [ U55S95$)u%Creates an expression that excludes columns by their name(s). Arguments: names: Name(s) of the columns to exclude. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2], "b": [3, 4], "c": ["x", "z"]}) >>> nw.from_native(df_native).select(nw.exclude("c", "a")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (2, 1) | | ┌─────┠| | │ b │ | | │ --- │ | | │ i64 │ | | â•žâ•â•â•â•â•â•¡ | | │ 3 │ | | │ 4 │ | | └─────┘ | └──────────────────┘ r«rÙ)rr r ÚEXCLUDEÚ frozensetrrÙs rPr«r«“s'€ô4 ”œ×)Ñ)¨9¼IÄgÈeÃnÓ>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 2], "b": [3, 4], "c": [0.123, 3.14]}) >>> nw.from_native(df_native).select(nw.nth(0, 2) * 2) ┌──────────────────┠|Narwhals DataFrame| |------------------| |pyarrow.Table | |a: int64 | |c: double | |---- | |a: [[2,4]] | |c: [[0.246,6.28]] | └──────────────────┘ Únth)Úindices)rrr r ÚNTH)râÚ flat_indicess rPrárá°s&€ô6˜7Ó#€LÜ ”œŸ™ u°lÑCÓ DÐDrYcóH•[[[RS55$)uûInstantiate an expression representing all columns. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> df_native = pd.DataFrame({"a": [1, 2], "b": [3.14, 0.123]}) >>> nw.from_native(df_native).select(nw.all() * 2) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 2 6.280 | | 1 4 0.246 | └──────────────────┘ Úall)rr r ÚALLrËrYrPÚall_rèÐs€ô" ”œŸ™ uÓ-Ó .Ð.rYcóH•[[[RS55$)u‘Return the number of rows. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2], "b": [5, None]}) >>> nw.from_native(df_native).select(nw.len()) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (1, 1) | | ┌─────┠| | │ len │ | | │ --- │ | | │ u32 │ | | â•žâ•â•â•â•â•â•¡ | | │ 2 │ | | └─────┘ | └──────────────────┘ Úlen©rr r Ú AGGREGATIONrËrYrPÚlen_ríås€ô, ”œ×-Ñ-¨uÓ5Ó 6Ð6rYcó.•[U6R5$)uLSum all values. Note: Syntactic sugar for ``nw.col(columns).sum()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> df_native = pd.DataFrame({"a": [1, 2], "b": [-1.4, 6.2]}) >>> nw.from_native(df_native).select(nw.sum("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 3 4.8 | └──────────────────┘ )rØÚsum©Úcolumnss rPrïrïþó€ô, ˆ=× Ñ Ó ÐrYcó.•[U6R5$)uGet the mean value. Note: Syntactic sugar for ``nw.col(columns).mean()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 8, 3], "b": [3.14, 6.28, 42.1]}) >>> nw.from_native(df_native).select(nw.mean("a", "b")) ┌─────────────────────────┠| Narwhals DataFrame | |-------------------------| |pyarrow.Table | |a: double | |b: double | |---- | |a: [[4]] | |b: [[17.173333333333336]]| └─────────────────────────┘ )rØÚmeanrðs rPrôrôs€ô4 ˆ=× Ñ Ó ÐrYcó.•[U6R5$)uŸGet the median value. Notes: - Syntactic sugar for ``nw.col(columns).median()`` - Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Arguments: columns: Name(s) of the columns to use in the aggregation function Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [4, 5, 2]}) >>> nw.from_native(df_native).select(nw.median("a")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (1, 1) | | ┌─────┠| | │ a │ | | │ --- │ | | │ f64 │ | | â•žâ•â•â•â•â•â•¡ | | │ 4.0 │ | | └─────┘ | └──────────────────┘ )rØÚmedianrðs rPrörö4s€ô< ˆ=× Ñ Ó !Ð!rYcó.•[U6R5$)u´Return the minimum value. Note: Syntactic sugar for ``nw.col(columns).min()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 2], "b": [5, 10]}) >>> nw.from_native(df_native).select(nw.min("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | a: int64 | | b: int64 | | ---- | | a: [[1]] | | b: [[5]] | └──────────────────┘ )rØÚminrðs rPrørøUs€ô4 ˆ=× Ñ Ó ÐrYcó.•[U6R5$)uSReturn the maximum value. Note: Syntactic sugar for ``nw.col(columns).max()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> df_native = pd.DataFrame({"a": [1, 2], "b": [5, 10]}) >>> nw.from_native(df_native).select(nw.max("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b | | 0 2 10 | └──────────────────┘ )rØÚmaxrðs rPrúrúrròrYcó†•U(dSUS3n[U5e[[[RU4SU0UDSS0D65$)Nz+At least one expression must be passed to `Ú`ÚexprsÚallow_multi_outputT)rDrr r Ú ELEMENTWISE)rUrýrÍrLs rPÚ_expr_with_horizontal_opr‹sU€Þ Ø;¸D¸6ÀÐCˆÜ˜‹oÐÜ ÜÜ × Ñ  $ñ Ø.3ð Ø7=ñ ØRVò ó ðrYc óJ•[[[RSX4US95$)uuCompute the Pearson's or Spearman rank correlation between two columns. Arguments: a: Column name or Expression b: Column name or Expression method: Correlation method ('pearson' or 'spearman') Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2, 3], "b": [0, 3, 2]}) >>> nw.from_native(df_native).select( ... pearson=nw.corr("a", "b", method="pearson"), ... spearman=nw.corr("a", "b", method="spearman"), ... ) ┌───────────────────────┠| Narwhals DataFrame | |-----------------------| |shape: (1, 2) | |┌──────────┬──────────â”| |│ pearson ┆ spearman │| |│ --- ┆ --- │| |│ f64 ┆ f64 │| |â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡| |│ 0.654654 ┆ 0.5 │| |└──────────┴──────────┘| └───────────────────────┘ Úcorr)rýÚmethodrë)ÚaÚbrs rPrr–s"€ô< ”œ×-Ñ-¨v¸a¸VÈFÑSÓ TÐTrYé)Úddofc óJ•[[[RSX4US95$)u•Compute the covariance between two columns. Arguments: a: Column name or Expression b: Column name or Expression ddof: "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2, 3], "b": [0, 3, 2]}) >>> nw.from_native(df_native).select( ... sample=nw.cov("a", "b"), population=nw.cov("a", "b", ddof=0) ... ) ┌───────────────────────┠| Narwhals DataFrame | |-----------------------| |shape: (1, 2) | |┌────────┬────────────â”| |│ sample ┆ population │| |│ --- ┆ --- │| |│ f64 ┆ f64 │| |â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡| |│ 1.0 ┆ 0.666667 │| |└────────┴────────────┘| └───────────────────────┘ Úcov)rýrrë)rrrs rPr r ·s"€ô< ”œ×-Ñ-¨u¸Q¸FÈÑNÓ OÐOrYcó,•[S/[U5Q76$)uPSum all values horizontally across columns. Warning: Unlike Polars, we support horizontal sum over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 2, 3], "b": [5, 10, None]}) >>> nw.from_native(df_native).with_columns(sum=nw.sum_horizontal("a", "b")) ┌────────────────────┠| Narwhals DataFrame | |--------------------| |shape: (3, 3) | |┌─────┬──────┬─────â”| |│ a ┆ b ┆ sum │| |│ --- ┆ --- ┆ --- │| |│ i64 ┆ i64 ┆ i64 │| |â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡| |│ 1 ┆ 5 ┆ 6 │| |│ 2 ┆ 10 ┆ 12 │| |│ 3 ┆ null ┆ 3 │| |└─────┴──────┴─────┘| └────────────────────┘ Úsum_horizontal©rr©rýs rPr r Øó€ô> $Ð$4Ð F´w¸u³~Ò FÐFrYcó,•[S/[U5Q76$)uHGet the minimum value horizontally across columns. Notes: We support `min_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_native = pa.table({"a": [1, 8, 3], "b": [4, 5, None]}) >>> nw.from_native(df_native).with_columns(h_min=nw.min_horizontal("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | a: int64 | | b: int64 | | h_min: int64 | | ---- | | a: [[1,8,3]] | | b: [[4,5,null]] | | h_min: [[1,5,3]] | └──────────────────┘ Úmin_horizontalr r s rPrrús€ô: $Ð$4Ð F´w¸u³~Ò FÐFrYcó,•[S/[U5Q76$)uyGet the maximum value horizontally across columns. Notes: We support `max_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> df_native = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, None]}) >>> nw.from_native(df_native).with_columns(h_max=nw.max_horizontal("a", "b")) ┌──────────────────────┠| Narwhals DataFrame | |----------------------| |shape: (3, 3) | |┌─────┬──────┬───────â”| |│ a ┆ b ┆ h_max │| |│ --- ┆ --- ┆ --- │| |│ i64 ┆ i64 ┆ i64 │| |â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡| |│ 1 ┆ 4 ┆ 4 │| |│ 8 ┆ 5 ┆ 8 │| |│ 3 ┆ null ┆ 3 │| |└─────┴──────┴───────┘| └──────────────────────┘ Úmax_horizontalr r s rPrrrrYcó4•\rSrSrSSjrSSjrSrg)ÚWheni<cóB•[[U5SS06UlXlg)NÚ ignore_nullsF)Úall_horizontalrÚ _predicateÚ_chain)ÚselfÚchainÚ predicatess rPÚ__init__Ú When.__init__=s€ô )¬'°*Ó*=ÐRÈEÑRˆŒØ rYcóf•/URQURU4P7n[RU5$r‘)rrÚThenÚ _from_chain)rr†Ú new_chains rPÚthenÚ When.thenEs/€Ø).then()`, and optionally followed by chained `.when().then()` calls. An `.otherwise()` can be appended at the end. If not appended, and the condition is not `True`, `None` will be returned. Arguments: predicates: Condition(s) that must be met in order to apply the subsequent statement. Accepts one or more boolean expressions, which are implicitly combined with `&`. String input is parsed as a column name. Returns: A "When" object, which `.then` can be called on. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> data = {"a": [1, 2, 3], "b": [5, 10, 15]} >>> df_native = pd.DataFrame(data) >>> nw.from_native(df_native).with_columns( ... nw.when(nw.col("a") < 2) ... .then(5) ... .when(nw.col("a") < 3) ... .then(6) ... .otherwise(6) ... .alias("a_when") ... ) ┌──────────────────┠|Narwhals DataFrame| |------------------| | a b a_when | | 0 1 5 5 | | 1 2 10 6 | | 2 3 15 6 | └──────────────────┘ rrË)r)rs rPrFrF{s€ôP Ð & 2Ñ &Ð&rYcó2•[S/[U5Q7SU06$)uBCompute the bitwise AND horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. ignore_nulls: Whether to ignore nulls: - If `True`, null values are ignored. If there are no elements, the result is `True`. - If `False`, Kleene logic is followed. Note that this is not allowed for pandas with classical NumPy dtypes when null values are present. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = { ... "a": [False, False, True, True, False, None], ... "b": [False, True, True, None, None, None], ... } >>> df_native = pa.table(data) >>> nw.from_native(df_native).select( ... "a", "b", all=nw.all_horizontal("a", "b", ignore_nulls=False) ... ) ┌─────────────────────────────────────────┠| Narwhals DataFrame | |-----------------------------------------| |pyarrow.Table | |a: bool | |b: bool | |all: bool | |---- | |a: [[false,false,true,true,false,null]] | |b: [[false,true,true,null,null,null]] | |all: [[false,false,true,null,false,null]]| └─────────────────────────────────────────┘ rrr ©rrýs rPrr¦s)€ôL $Øð Ü" 5›>ò Ø8Dñ ðrYc ó¨•[U5(a Sn[U5e[U5(a„U(dU(d Sn[U5eOh[U[5(a3[ SUR 555(a Sn[U5eO [US5(a Sn[U5e[[[RSXS95$)u< Return an expression representing a literal value. Arguments: value: The value to use as literal. Can be a scalar value, list, tuple, or dict. Lists and tuples are converted to `List` dtype, dicts to `Struct` dtype. dtype: The data type of the literal value. If not provided, the data type will be inferred by the native library. For empty lists/dicts, dtype must be specified explicitly. Examples: Scalar literals: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> df_nw = nw.from_native(pa.table({"a": [1, 2]})) >>> df_nw.with_columns(nw.lit(3)) ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | a: int64 | | literal: int64 | | ---- | | a: [[1,2]] | | literal: [[3,3]] | └──────────────────┘ List literals (creates a List column): >>> df_nw.with_columns(nw.lit([1, 2, 3]).alias("list_col")) ┌─────────────────────────────┠| Narwhals DataFrame | |-----------------------------| |pyarrow.Table | |a: int64 | |list_col: list | | child 0, item: int64 | |---- | |a: [[1,2]] | |list_col: [[[1,2,3],[1,2,3]]]| └─────────────────────────────┘ Dict literals (creates a Struct column): >>> df_nw.with_columns(nw.lit({"x": 1, "y": 2}).alias("struct_col")) ┌──────────────────────────────────────┠| Narwhals DataFrame | |--------------------------------------| |pyarrow.Table | |a: int64 | |struct_col: struct| | child 0, x: int64 | | child 1, y: int64 | |---- | |a: [[1,2]] | |struct_col: [ | | -- is_valid: all not null | | -- child 0 type: int64 | |[1,1] | | -- child 1 type: int64 | |[2,2]] | └──────────────────────────────────────┘ zvnumpy arrays are not supported as literal values. Consider using `with_columns` to create a new column from the array.zZCannot infer dtype for empty nested structure. Please provide an explicit dtype parameter.c3ó8# •UHn[U5v• M g7fr‘)r)rªÚvs rPr¬Úlit..sé€Ð@²¨AÔ$ Q×'Ð'²ùó‚z7Nested structures with nested values are not supported.rÚlit)r†rW) rrDrr’rwÚanyrVrFrr r ÚLITERAL)r†rWrLs rPrVrVÑsÀôBe×Ñð Sð ô˜‹oÐܘ×ÑÞÞØrÜ  “oÐ%ðô˜œt× $Ñ $ÜÑ@°·±´Ó@×@Ñ@ØOÜ)¨#Ó.Ð.ðAô˜u Q™x× (Ñ (ØKˆCÜ% cÓ*Ð *Ü ”œ×)Ñ)¨5¸ÑKÓ LÐLrYcó2•[S/[U5Q7SU06$)uÃCompute the bitwise OR horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. ignore_nulls: Whether to ignore nulls: - If `True`, null values are ignored. If there are no elements, the result is `False`. - If `False`, Kleene logic is followed. Note that this is not allowed for pandas with classical NumPy dtypes when null values are present. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> data = { ... "a": [False, False, True, True, False, None], ... "b": [False, True, True, None, None, None], ... } >>> df_native = pl.DataFrame(data) >>> nw.from_native(df_native).select( ... "a", "b", any=nw.any_horizontal("a", "b", ignore_nulls=False) ... ) ┌─────────────────────────┠| Narwhals DataFrame | |-------------------------| |shape: (6, 3) | |┌───────┬───────┬───────â”| |│ a ┆ b ┆ any │| |│ --- ┆ --- ┆ --- │| |│ bool ┆ bool ┆ bool │| |â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡| |│ false ┆ false ┆ false │| |│ false ┆ true ┆ true │| |│ true ┆ true ┆ true │| |│ true ┆ null ┆ true │| |│ false ┆ null ┆ null │| |│ null ┆ null ┆ null │| |└───────┴───────┴───────┘| └─────────────────────────┘ Úany_horizontalrr rPs rPrZrZ's)€ôV $Øð Ü" 5›>ò Ø8Dñ ðrYcó,•[S/[U5Q76$)u5Compute the mean of all values horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = {"a": [1, 8, 3], "b": [4, 5, None], "c": ["x", "y", "z"]} >>> df_native = pa.table(data) We define a dataframe-agnostic function that computes the horizontal mean of "a" and "b" columns: >>> nw.from_native(df_native).select(nw.mean_horizontal("a", "b")) ┌──────────────────┠|Narwhals DataFrame| |------------------| | pyarrow.Table | | a: double | | ---- | | a: [[2.5,6.5,3]] | └──────────────────┘ Úmean_horizontalr r s rPr\r\Ws€ô6 $Ð$5Ð G¼À»Ò GÐGrYr®F©rÅrcóR•[/[U/5QUQ5n[S/UQ7XS.6$)u¸Horizontally concatenate columns into a single string column. Arguments: exprs: Columns to concatenate into a single string column. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. Non-`String` columns are cast to `String`. *more_exprs: Additional columns to concatenate into a single string column, specified as positional arguments. separator: String that will be used to separate the values of each column. ignore_nulls: Ignore null values (default is `False`). If set to `False`, null values will be propagated and if the row contains any null values, the output is null. Examples: >>> import pandas as pd >>> import narwhals as nw >>> >>> data = { ... "a": [1, 2, 3], ... "b": ["dogs", "cats", None], ... "c": ["play", "swim", "walk"], ... } >>> df_native = pd.DataFrame(data) >>> ( ... nw.from_native(df_native).select( ... nw.concat_str( ... [nw.col("a") * 2, nw.col("b"), nw.col("c")], separator=" " ... ).alias("full_sentence") ... ) ... ) ┌──────────────────┠|Narwhals DataFrame| |------------------| | full_sentence | | 0 2 dogs play | | 1 4 cats swim | | 2 NaN | └──────────────────┘ Ú concat_strr])rr)rýrÅrÚ more_exprsÚ flat_exprss rPr_r_usA€ôZÐ9œ7 E 7Ó+Ð9¨jÐ9Ó:€JÜ #Øð Ø!ñ Ø-6ò ðrYc óˆ•[/[U/5QUQ5nUVs/sH@n[U[5(aM[U5(aM,[ U5(aM>UPMB nnU(a.S[<SSR SU553n[ U5e[[[RSUSS95$s snf)u€Folds the columns from left to right, keeping the first non-null value. Arguments: exprs: Columns to coalesce, must be a str, nw.Expr, or nw.Series where strings are parsed as column names and both nw.Expr/nw.Series are passed through as-is. Scalar values must be wrapped in `nw.lit`. *more_exprs: Additional columns to coalesce, specified as positional arguments. Raises: TypeError: If any of the inputs are not a str, nw.Expr, or nw.Series. Examples: >>> import polars as pl >>> import narwhals as nw >>> data = [ ... (1, 5, None), ... (None, 6, None), ... (None, None, 9), ... (4, 8, 10), ... (None, None, None), ... ] >>> df = pl.DataFrame(data, schema=["a", "b", "c"], orient="row") >>> nw.from_native(df).select(nw.coalesce("a", "b", "c", nw.lit(-1))) ┌──────────────────┠|Narwhals DataFrame| |------------------| | shape: (5, 1) | | ┌─────┠| | │ a │ | | │ --- │ | | │ i64 │ | | â•žâ•â•â•â•â•â•¡ | | │ 1 │ | | │ 6 │ | | │ 9 │ | | │ 4 │ | | │ -1 │ | | └─────┘ | └──────────────────┘ z,All arguments to `coalesce` must be of type zJ, Expr, or Series. Got the following invalid arguments (type, value): z, c3óN# •UHn[[U5U45v• M g7fr‘)Úreprr©rªrns rPr¬Úcoalesce..ßs é€ÐEº9°aœt¤T¨!£W¨a L×1Ð1º9ùs‚#%ÚcoalesceTr4) rr’rŽr r Újoinrƒrr r rÿ)rýr`rar7Ú non_exprsrLs rPrgrg¨sÍ€ôXÐ9œ7 E 7Ó+Ð9¨jÐ9Ó:€JñóâˆDܘ4¤×%ó ä)0°¯ó ä:CÀD¿/÷ Ùððö à:¼3¹'ðBà—Y‘YÑE¹9ÓEÓEÐFð Hð ô ˜‹nÐä ÜÜ × Ñ  *°JÐSWñ ó ðùòsžB?»B?Á B?ÁB?có†•URS5=n[U5:waSUS[U5S3n[U5e/n[U5n[ UR S55HPupgUS:”aUR [U55 [U5S:”dM6UR [U55 MR [USS9$)uðFormat expressions as a string. Arguments: f_string: A string that with placeholders. args: Expression(s) that fill the placeholders. Examples: >>> import duckdb >>> import narwhals as nw >>> rel = duckdb.sql("select * from values ('a', 1), ('b', 2), ('c', 3) df(a, b)") >>> df = nw.from_native(rel) >>> df.with_columns(formatted=nw.format("foo_{}_bar_{}", nw.col("a"), "b")) ┌─────────────────────────────────┠| Narwhals LazyFrame | |---------------------------------| |┌─────────┬───────┬─────────────â”| |│ a │ b │ formatted │| |│ varchar │ int32 │ varchar │| |├─────────┼───────┼─────────────┤| |│ a │ 1 │ foo_a_bar_1 │| |│ b │ 2 │ foo_b_bar_2 │| |│ c │ 3 │ foo_c_bar_3 │| |└─────────┴───────┴─────────────┘| └─────────────────────────────────┘ z{}zFnumber of placeholders should equal the number of arguments. Expected z arguments, got r‹rr®rÄ) ÚcountrêrDÚiterÚ enumerateÚsplitÚappendÚnextrVr_)Úf_stringÚargsÚn_placeholdersrLrýÚitÚiÚss rPÚformatrwêsÀ€ð4#Ÿ.™.¨Ó.Ð.ˆ´3°t³9Ó<ØVÐWeÐVfÐfvÔwzÐ{óxAðwBðBCðDˆÜ˜‹oÐà €EÜ ˆd‹€Bܘ(Ÿ.™.¨Ó.Ö/‰ˆØ ˆq‹5Ø L‰Lœ˜b›Ô "Ü ˆq‹6A:Ø L‰Lœ˜Q›Ö ñ 0ô e rÑ *Ð*rYc óÆ•/S[U55QSUR55QnU(d Sn[U5e[[ [ R SUSS95$)u8Collect columns into a struct column. Arguments: *exprs: Column(s) to collect into a struct column, specified as positional arguments. Accepts only expression input. Strings are parsed as column names, other non-expression inputs are not allowed. **named_exprs: Additional columns to collect into the struct column, specified as keyword arguments. The columns will be renamed to the keyword used. Examples: Collect all columns of a dataframe into a struct by passing `pl.all()`. >>> import duckdb >>> import narwhals as nw >>> rel = duckdb.sql( ... "select * from values (1, 'a', True, [1, 2]), (2, 'b', False, [3]) df(int, str, bool, list)" ... ) >>> df = nw.from_native(rel) >>> df.select(nw.struct(nw.all()).alias("my_struct")) ┌────────────────────────────────────────────────────────────────────┠| Narwhals LazyFrame | |--------------------------------------------------------------------| |┌──────────────────────────────────────────────────────────────────â”| |│ my_struct │| |│ struct("int" integer, str varchar, bool boolean, list integer[]) │| |├──────────────────────────────────────────────────────────────────┤| |│ {'int': 1, 'str': a, 'bool': true, 'list': [1, 2]} │| |│ {'int': 2, 'str': b, 'bool': false, 'list': [3]} │| |└──────────────────────────────────────────────────────────────────┘| └────────────────────────────────────────────────────────────────────┘ It's possible to specify the column names directly and use named expressions: >>> df.select( ... nw.struct("int", x=nw.col("str").str.len_chars(), q="bool").alias( ... "my_struct" ... ) ... ) ┌──────────────────────────────────────────────┠| Narwhals LazyFrame | |----------------------------------------------| |┌────────────────────────────────────────────â”| |│ my_struct │| |│ struct("int" integer, x bigint, q boolean) │| |├────────────────────────────────────────────┤| |│ {'int': 1, 'x': 1, 'q': true} │| |│ {'int': 2, 'x': 1, 'q': false} │| |└────────────────────────────────────────────┘| └──────────────────────────────────────────────┘ c3ó8# •UHn[U5v• M g7fr‘)r res rPr¬Ústruct..Gsé€Ð 6¢~ !Ô ˜1× Ð ¢~ùrUc3óZ# •UH!up[U5RU5v• M# g7fr‘)r rg)rªÚnrns rPr¬rzHs(é€Ð GÒ3F©4¨1Ô ˜1Ó × #Ñ # A× &Ð &Ò3Fùs‚)+z*expected at least 1 expression in 'struct'ÚstructTr4)rrKrDrr r rÿ)rýÚ named_exprsrarLs rPr}r}sj€ðhÙ 6¤w¨u¤~Ó 6ðá G°;×3DÑ3DÔ3FÓ Gð€Jö Ø:ˆÜ˜‹oÐä ÜÜ × Ñ  (°*ÐQUñ ó ðrYc ó•[U5Vs/sHn[U5PM nnU(d Sn[U5e[[ [ R SUSS95$s snf)ußCollect columns into a list column. Arguments: *exprs: Column(s) to collect into a list column, specified as positional arguments. Accepts only expression input. Strings are parsed as column names, other non-expression inputs are not allowed. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> data = {"a": [1, 2, 3], "b": [4, 5, 6]} >>> df = nw.from_native(pl.DataFrame(data)) >>> df.with_columns(nw.list("a", "b").alias("a_b")) ┌─────────────────────────┠| Narwhals DataFrame | |-------------------------| |shape: (3, 3) | |┌─────┬─────┬───────────â”| |│ a ┆ b ┆ a_b │| |│ --- ┆ --- ┆ --- │| |│ i64 ┆ i64 ┆ list[i64] │| |â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡| |│ 1 ┆ 4 ┆ [1, 4] │| |│ 2 ┆ 5 ┆ [2, 5] │| |│ 3 ┆ 6 ┆ [3, 6] │| |└─────┴─────┴───────────┘| └─────────────────────────┘ z(expected at least 1 expression in 'list'ÚlistTr4)rr rDrr r rÿ)rýrnrarLs rPÚlist_rUs[€ô<07°u¬~Ó>ª~¨!Ô" 1Ö%©~€JÐ>Þ Ø8ˆÜ˜‹oÐä Ü”×%Ñ% v°ZÐTXÑYó ðùò ?sŽA)rKzIterable[FrameT]r>r0r'r3r‘) rUrŽrVrrWúIntoDType | NonerSú&IntoBackend[EagerAllowed | PluginName]r'z Series[Any]) r}zMapping[str, Any]rrú2IntoSchema | Mapping[str, IntoDType | None] | NonerSz-IntoBackend[EagerAllowed | PluginName] | NonerpzModuleType | Noner'úDataFrame[Any])r}zMapping[str, Series[Any] | Any]r'z/tuple[dict[str, Series[Any] | Any], ModuleType])r}zSequence[Mapping[str, Any]]rrr„rSrƒr'r…)r}r9rrr:rSrƒr'r…)r“rr'zTypeIs[_IntoSchema])rr(rSrƒr'r…)r'zdict[str, str])r'r() rÇr2rSrƒrÅrŽrÍrr'r…) rÇr2rSú!IntoBackend[Backend | PluginName]rÅrŽrÍrr'úLazyFrame[Any])rÇr2rSrƒrÍrr'r…)rÇr2rSr†rÍrr'r‡)rÚzstr | Iterable[str]r'r)râzint | Sequence[int]r'r)r'r)rñrŽr'r)rUrŽrýr5rÍrr'r)Úpearson)rr5rr5rr1r'r)rr5rr5rÚintr'r)rýr%r'rrI)rýr%rÚboolr'r)r†r8rWr‚r'r) rýr%r`r5rÅrŽrrŠr'r)rýr%r`r)r'r)rqrŽrrr5r'r)rýúIntoExpr | Sequence[IntoExpr]r~r5r'r)rýr‹r'r)yÚ __future__rr rÚcollections.abcrrrÚtypingrrÚnarwhals._expression_parsingr r r r r Únarwhals._utilsrrrrrrrrrrrCrrrrÚnarwhals.exceptionsrÚ narwhals.exprrÚnarwhals.schemarÚnarwhals.translaterr Útypesr!r"Útyping_extensionsr#r$Únarwhals._nativer%r&r'Únarwhals._translater(Únarwhals._typingr)r*r+r,Únarwhals.dataframer-r.Únarwhals.seriesr/Únarwhals.typingr0r1r2r3r4r5r6r7r8r9r;rJrIrXrTr|rvr‰rrŒr•r¢r»rÂrÌrÑrÔrÖrØr«rárèrírïrôrörørúrrr r rrrr rFrrVrZr\r_rgrwr}rrËrYrPÚrsïðÞ"ãÛ ß7Ñ7ß%÷õ÷ ÷ ÷ ÷óõ 6ÝÝ"ß5æÝ Ý ç.çOÑOÝ2ßOÓOß7Ý&÷ ÷ ÷ ðA€KÓ@ðBØ*.ñ JØ ðJà >ðJð;ð Jð (ð Jð õ Jó3ðJðZ "Ø )ð "à4ô "ð BFð>LØ %ð>Là >ð>Lð4ð >Lð õ >LðF15ðQØ ðQà -ðQð4ð Qð õ Qôhð;Ø ð;Ø.Tð;àô;ô|ô*$ôN"ð.ñ 7Ø ð7ð4ð7ðð 7ð ð 7ð õ 7ð|ñ 8Ø ð8ð/ð8ðð 8ð ð 8ð õ 8ðv7Ø ð7Ø$Jð7ØVYð7àô7ðtNØ ðNØ$EðNØQTðNàôNôbAô<Xô:Eô@/ô*7ô2ô2 ô:"ôBô:ô2öUðB23÷PôBGôDGô@G÷D +ñ +ô.4ˆ4ô.4ôb('ôV(öVSMôl-ô`HðBØñ 0Ø (ð0àð0ðð0ðð 0ð  õ 0ðf?Ø (ð?Ø7Rð?à ô?ôD%+ôP@õF%rY