Wh UddlmZddlZddlZddlmZmZmZmZm Z m Z ddl m Z ddl mZmZddlmZmZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZEmFZFmGZGe!rkddlmHZHddlImJZJddlKZLddlMZNddlOZPddlQmRZRmSZSmTZTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ddl_m`Z`maZambZbddlcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpddlqmrZrmsZsmtZtddlumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZddlmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZeZded<e'd e(ee"ee"ee"f!Ze'd"Ze'd#Ze'd$Ze'd%Ze'd&Ze'd'Ze'd(Ze'd)d*!ZeTd+Ze'd,Ze'd-Ze'd.ZGd/d0e&ZGd1d2e&ZGd3d4e&Ze'd5Ze'd6d78Ze'd9d78Ze'd:d;!ZdZded?<Gd@dAe&eZGdBdCe&eZGdDdEe&ZGdFdGe&ZGdHdIe&ZGdJdKeee&ZGdLd;eee&ZGdMdNee&ZGdOdPeZGdQdRe,ZejdSejdTejdUejdVejdWejdWejdXejdYejdZejd[ejd\i Zd]ed^<ejd_ejd`ejdaejdbiZdcedd< edefddgZeddhZddiZddjZddkZddlZe* ddmZe* ddnZe* ddoZe* ddpZe* ddqZe* ddrZe* ddsZe* ddtZe* dduZe* ddvZe* ddwZe* ddxZe* ddyZe* ddzZe* dd{Zdd|Zdd}Z dd~ZddZ ddd ddZddZe!r eed7Zn#ddlZeݐjdk\r eed7ZnddZddZ ddZ ddZddZddZ ddZddZ ddZddZddZ ddZ ddZddZddZddZ ddZddZddZ ddZddd ddZ ddZddZ ddZddZ ddZ ddZddZddZddZddZ ddZ ddZ ddZ ddZ d dZd dZd dZd dZd dZddZ ddZddZddZ ddZ GddZ ddZ GddZ ddZ ddZddZddddZGdde$eZedfdd„ZddÄZGdĄdeeee&eZGdƄde&eZGdȄdɫZddʄZdd˄Zy() annotationsN) Collection ContainerIterableIteratorMappingSequence)timezone)Enumauto)cache lru_cachepartialwraps) find_spec)getattr_staticgetdoc)chain) attrgetter) token_hex) TYPE_CHECKINGAnyCallableGenericLiteralProtocolTypeVarUnioncastoverload) NoAutoEnum)issue_deprecation_warning) assert_never deprecated)get_cudfget_dask_dataframe get_duckdbget_ibis get_modin get_pandas get_polars get_pyarrowget_pyspark_connectget_pyspark_sql get_sqlframeis_narwhals_seriesis_narwhals_series_intis_numpy_array_1dis_numpy_array_1d_intis_pandas_like_dataframeis_pandas_like_series)ColumnNotFoundErrorDuplicateErrorInvalidOperationError)Set) ModuleType) Concatenate LiteralString ParamSpecSelf TypeAliasTypeIs) CompliantExprCompliantExprTCompliantFrameTCompliantSeriesOrNativeExprT_coCompliantSeriesTNativeSeriesT_co) EvalNamesNativeDataFrameTNativeLazyFrameT) Namespace _NativeArrow _NativeCuDF _NativeDask _NativeDuckDB _NativeIbis _NativeModin _NativePandas_NativePandasLike _NativePolars_NativePySpark_NativePySparkConnect_NativeSQLFrame)ArrowStreamExportableIntoArrowTableToNarwhalsT_co)Backend IntoBackend _ArrowImpl _CuDFImpl _DaskImpl _DuckDBImpl_EagerAllowedImpl _IbisImpl_LazyAllowedImpl_LazyFrameCollectImpl _ModinImpl _PandasImpl_PandasLikeImpl _PolarsImpl_PySparkConnectImpl _PySparkImpl _SQLFrameImpl DataFrame LazyFrameDTypeSeries)CompliantDataFrameCompliantLazyFrameCompliantSeriesDTypes FileSource IntoSeriesTMultiIndexSelectorSingleIndexSelectorSizedMultiIndexSelectorSizeUnitSupportsNativeNamespaceTimeUnit_1DArray _SliceIndex _SliceName _SliceNoner?UnknownBackendNameFrameOrSeriesT)bound_T1_T2_T3_T4_T5_T6_T7_FnzCallable[..., Any]PRR1R2ceZdZUded<y)_SupportsVersionstr __version__N__name__ __module__ __qualname____annotations__I/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/_utils.pyrrsrrceZdZdddZy) _SupportsGetNcyNrselfinstanceowners r__get__z_SupportsGet.__get__srr)rrr Any | Nonereturnr)rrrrrrrrrsQrrceZdZeddZy)_StoresColumnscyrrrs rcolumnsz_StoresColumns.columnss,/rN)r Sequence[str])rrrpropertyrrrrrrs / /rr_T NativeT_coT) covariant CompliantT_co _ContextT _FullContextz&Callable[Concatenate[_ContextT, P], R]_Methodz Callable[Concatenate[_T, P], R2] _Constructorc"eZdZdZeddZy) _StoresNativezProvides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table cy)zReturn the native object.Nrrs rnativez_StoresNative.native rN)rr)rrr__doc__rrrrrrr  rrc"eZdZdZeddZy)_StoresCompliantzProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame cy)zReturn the compliant object.Nrrs r compliantz_StoresCompliant.compliantrrN)rr)rrrrrrrrrrrrrrceZdZeddZy)_StoresBackendVersioncy)z#Version tuple for a native package.Nrrs r_backend_versionz&_StoresBackendVersion._backend_versionrrNrtuple[int, ...])rrrrrrrrrrs   rrceZdZUded<y)_StoresVersionVersion_versionNrrrrrrs ,rrceZdZUded<y)_StoresImplementationImplementation_implementationNrrrrrrs ##IrrceZdZdZy)_LimitedContextzEProvides 2 attributes. - `_implementation` - `_version` NrrrrrrrrrsrrceZdZdZy)rz^Provides 3 attributes. - `_implementation` - `_backend_version` - `_version` NrrrrrrsrceZdZdZddZy)ValidateBackendVersionz=Ensure the target `Implementation` is on a supported version.c8|jj}y)zRaise if installed version below `nw._utils.MIN_VERSIONS`. **Only use this when moving between backends.** Otherwise, the validation will have taken place already. N)rr)r_s r_validate_backend_versionz0ValidateBackendVersion._validate_backend_versions  1 1 3rN)rNone)rrrrrrrrrrs G4rrceZdZeZeZeZeddZeddZ ed dZ ed dZ ed dZ y) rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)rJ)rV1narwhals.stable.v1._namespacerJV2narwhals.stable.v2._namespacenarwhals._namespace)r NamespaceV1 NamespaceV2rJs r namespacezVersion.namespaces5 7::  N  7::  N 1rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)dtypes)rrnarwhals.stable.v1rrnarwhals.stable.v2narwhals)r dtypes_v1 dtypes_v2rs rrzVersion.dtypes s4 7::  >  7::  > # rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)rl)rrrrlrrnarwhals.dataframe)r DataFrameV1 DataFrameV2rls r dataframezVersion.dataframe5 7::  C  7::  C 0rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)rm)rrrrmrrr)r LazyFrameV1 LazyFrameV2rms r lazyframezVersion.lazyframe&rrcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nrrp)rrrrqrrnarwhals.series)rSeriesV1SeriesV2rqs rserieszVersion.series4s2 7::  =O 7::  =O* rN)rztype[Namespace[Any]])rru)rztype[DataFrame[Any]])rztype[LazyFrame[Any]])rztype[Series[Any]]) rrrr rrMAINrrrrrrrrrrrsy B B 6D           rrc&eZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z d"dZe d#dZed$dZe d%dZd&dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZ d'dZ!d'dZ"d(d Z#y!))rz?Implementation of native object (pandas, Polars, PyArrow, ...).pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframezpyspark[connect]unknownc,t|jSr)rvaluers r__str__zImplementation.__str___s4::rcVttjttjt tj ttjttjttjttjttj t#tj$t'tj(t+tj,i }|j/|tj0S)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. )r*rPANDASr)MODINr%CUDFr,PYARROWr.PYSPARKr+POLARSr&DASKr'DUCKDBr(IBISr/SQLFRAMEr-PYSPARK_CONNECTgetUNKNOWN)clsnative_namespacemappings rfrom_native_namespacez$Implementation.from_native_namespacebs L.// K-- J++ M>11  ~55 L.//  ."5"5 L.// J++ NN33  !>#A#A  {{+^-C-CDDrcR ||S#t$rtjcYSwxYw)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. ) ValueErrorrr)r backend_names r from_stringzImplementation.from_stringzs- *|$ $ *!)) ) *s  &&ct|tr|j|St|tr|S|j |S)zInstantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. ) isinstancerrrr)rbackends r from_backendzImplementation.from_backendsL'3' OOG $ '>2 **73  rc|tjur d}t||jtj ||j }t|S)zCReturn the native namespace module corresponding to Implementation.z:Cannot return native namespace from UNKNOWN Implementation)rrAssertionErrorr_IMPLEMENTATION_TO_MODULE_NAMErr_import_native_namespace)rmsg module_names rto_native_namespacez"Implementation.to_native_namespacesM >)) )NC % % 488tzzJ ' 44rc&|tjuS)a7Return whether implementation is pandas. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas() True )rr rs r is_pandaszImplementation.is_pandas~,,,,rcd|tjtjtjhvS)aLReturn whether implementation is pandas, Modin, or cuDF. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas_like() True )rr r r rs ris_pandas_likezImplementation.is_pandas_likes(--~/C/C^EXEXYYYrcd|tjtjtjhvS)aIReturn whether implementation is pyspark or sqlframe. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_spark_like() False )rrrrrs r is_spark_likezImplementation.is_spark_likes1  " "  # #  * *   rc&|tjuS)a7Return whether implementation is Polars. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_polars() True )rrrs r is_polarszImplementation.is_polarsr-rc&|tjuS)a4Return whether implementation is cuDF. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_cudf() False )rr rs ris_cudfzImplementation.is_cudf~****rc&|tjuS)a6Return whether implementation is Modin. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_modin() False )rr rs ris_modinzImplementation.is_modins~++++rc&|tjuS)a:Return whether implementation is PySpark. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark() False )rrrs r is_pysparkzImplementation.is_pyspark~----rc&|tjuS)aBReturn whether implementation is PySpark. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark_connect() False )rrrs ris_pyspark_connectz!Implementation.is_pyspark_connects~5555rc&|tjuS)a:Return whether implementation is PyArrow. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyarrow() False )rrrs r is_pyarrowzImplementation.is_pyarrow r;rc&|tjuS)a4Return whether implementation is Dask. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_dask() False )rrrs ris_daskzImplementation.is_daskr6rc&|tjuS)a8Return whether implementation is DuckDB. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_duckdb() False )rrrs r is_duckdbzImplementation.is_duckdb'r-rc&|tjuS)a4Return whether implementation is Ibis. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_ibis() False )rrrs ris_ibiszImplementation.is_ibis4r6rc&|tjuS)a<Return whether implementation is SQLFrame. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_sqlframe() False )rrrs r is_sqlframezImplementation.is_sqlframeAs~....rct|S)zReturns backend version.backend_versionrs rrzImplementation._backend_versionNs t$$rNrr)r type[Self]rr:rr)rrLrrrr)rrLr"z)IntoBackend[Backend] | UnknownBackendNamerr)rr:)rboolr)$rrrrr r r rrrrrrrrrr  classmethodrrr#r*r,r/r1r3r5r8r:r=r?rArCrErGrrrrrrCs'I F E DG!G! F D F DH"(O)G!E E+5E EE. * *  "K   5 - Z " - + , . 6 . + - + /%rr)rO)r) ) )rP)r)irQ)rO))rPrz(Mapping[Implementation, tuple[int, ...]] MIN_VERSIONSzdask.dataframez modin.pandasz pyspark.sqlzpyspark.sql.connectzMapping[Implementation, str]r&)maxsizecddlm}||S)Nr) import_module) importlibr_)r)r_s rr'r'js'  %%rct|ts t||tjur d}t ||}t j ||j}t|}|jrddl }|j}n@|js|jrddl}|}n|jrddl}|}n|}t#|} | t$|x} krd|d| d| }t'|| S)Nz9Cannot return backend version from UNKNOWN ImplementationrzMinimum version of z supported by Narwhals is z , found: )r!rr#rr%r&rrr'rGsqlframe._versionrr:r=rrAr parse_versionr[r) implementationr(implr)rr into_versionrrversion min_versions rrJrJts nn 5^$///IS!! D044T4::FK/ <  ((  d557  ' L)Gd!33+4#D6)CK=PYZaYbco Nrcbtt|dk(rt|dr |dS|S)NrOr)listlen _is_iterable)argss rflattenrns. CIN|DG/DQ PP4 PPrc8t|ttfs|fS|Sr)r!rjtuple)args rtupleifyrrs cD%= )v Jrczddlm}tx}"t||j|jfsDt x}Rt||j|j |j|jfrdt|d}t|t|txrt|tt|f S)Nrrpz(Expected Narwhals class or scalar, got: z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?) rrqr*r!rlr+Exprrmqualified_type_name TypeErrorrrbytes)rqrqpdplr(s rrlrls&| (Zbii=V-W| ( sRYYr||L M77J37O6RS3 3 n c8 $ RZc5&=Q-R)RRrct|tr|n |j}tjdd|}t d|j dDS)zSimple version parser; split into a tuple of ints for comparison. Arguments: version: Version string, or object with one, to parse. Returns: Parsed version number. z (\D?dev.*$)c3\K|]$}ttjdd|&yw)z\Dr{N)intresub).0vs r z parse_version..s"KqRVVE2q)*Ks*,.)r!rrr~rrpsplit)rg version_strs rrcrcsH(5'7;N;NK&&[9K KK4E4Ec4JK KKrcyrr obj_or_cls cls_or_tuples risinstance_or_issubclassrsrcyrrrs rrr rcyrrrs rrrs"rcyrrrs rrr+.rcyrrrs rrrs%(rcyrrrs rrrs7:rcyrrrs rrrrrcyrrrs rrrs CFrcyrrrs rrrs14rcyrrrs rrrs ORrcyrrrs rrrs7:rcyrrrs rrr s rcyrrrs rrrs =@rcyrrrs rrrsrcyrrrs rrr.srcddlm}t||r t||St||xst|txr t ||S)Nrrn)narwhals.dtypesror!type issubclass)rrros rrr4sF%*e$*l33 j, / :t$MJ )Mrcddlmmtfd|Dstfd|Dryd|Dcgc] }t |c}}t |cc}w)Nrrkc36K|]}t|ywrr!)ritemrls rrz$validate_laziness..As 94:dI & 9c36K|]}t|ywrr)rrrms rrz$validate_laziness..Bs :DJtY ' :rzGThe items to concatenate should either all be eager, or all lazy, got: )rrlrmallrrv)itemsrr(rlrms @@rvalidate_lazinessr>sW7 95 99 :E :: SlqTrdhUYZ^U_TrSs tC C.UssAcddlm}ddlm}d d}t d|}t d|}t t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt|t|k7r%d t|d t|}t||S) aAlign `lhs` to the Index of `rhs`, if they're both pandas-like. Arguments: lhs: Dataframe or Series. rhs: Dataframe or Series to align with. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this only checks that `lhs` and `rhs` are the same length. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2]}, index=[3, 4]) >>> s_pd = pd.Series([6, 7], index=[4, 3]) >>> df = nw.from_native(df_pd) >>> s = nw.from_native(s_pd, series_only=True) >>> nw.to_native(nw.maybe_align_index(df, s)) a 4 2 3 1 r)PandasLikeDataFrame)PandasLikeSeriesrc6|js d}t|y)Nz'given index doesn't have a unique index) is_uniquer)indexr(s r_validate_indexz*maybe_align_index.._validate_indexms;CS/ !r_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrrr)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrrr!getattrrrr_with_compliant _with_nativelocrrkr)lhsrhsrrrlhs_anyrhs_anyr(s rmaybe_align_indexrIsJBD=" 5#G5#G+T24G WW&8$?AT U0077==>0077==>&&  $ $ 1 1((//33G4L4L4S4S4Y4YZ   +T24G WW&94@BR S0077==>1188>>?&&  $ $ 1 1((//33--44::   ,d35E WW&8$?AT U1188>>?0077==>&&  % % 2 2))0044,,3399   ,d35E WW&94@BR S1188>>?1188>>?&&  % % 2 2))0044--44::    7|s7|#Fs7|nTYZ]^eZfYgho Jrctd|}|j}t|s t|r |jSy)aGet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this returns `None`. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.maybe_get_index(df) RangeIndex(start=0, stop=2, step=1) >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) rN)r to_nativer4r5r)objobj_any native_objs rmaybe_get_indexrs=:5#G""$J +/DZ/P r)rcVddlm}td|}|j}|| d}t||s| d}t||.t |r|Dcgc] }||dc}n ||d}n|}t |r9|j |jj|j|St|r^ddl m } |r d }t|| |||jj }|j |jj|S|Scc}w) aSet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: object for which maybe set the index (can be either a Narwhals `DataFrame` or `Series`). column_names: name or list of names of the columns to set as index. For dataframes, only one of `column_names` and `index` can be specified but not both. If `column_names` is passed and `df` is a Series, then a `ValueError` is raised. index: series or list of series to set as index. Returns: Same type as input. Raises: ValueError: If one of the following conditions happens - none of `column_names` and `index` are provided - both `column_names` and `index` are provided - `column_names` is provided and `df` is a Series Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_set_index(df, "b")) # doctest: +NORMALIZE_WHITESPACE a b 4 1 5 2 r)rrz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedT) pass_through) set_indexz/Cannot set index using column names on a Series)rd)narwhals.translaterrrrlr4rrrrr5narwhals._pandas_like.utilsrr) r column_namesrrdf_anyrr(idxkeysrs rmaybe_set_indexrs7^- % F!!#JE$5Ho EMCo E";@ @3Ys . @5t4  +%%  # # 0 01E1Ed1K L  Z(9 CCS/ !  00@@ %%f&>&>&K&KJ&WXX M1 AsD&ctd|}|j}t|rX|j}t ||r|S|j |j j|jdSt|rX|j}t ||r|S|j |jj|jdS|S)aReset the index to the default integer index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already resets the index for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}, index=([6, 7])) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_reset_index(df)) a b 0 1 4 1 2 5 >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) rT)drop) rrr4__native_namespace___has_default_indexrrr reset_indexr5r)rrrrs rmaybe_reset_indexr%s>5#G""$J +"779 j*: ;N&&  $ $ 1 1*2H2Hd2H2S T  Z("779 j*: ;N&&  % % 2 2:3I3It3I3T U   Nr)strict)rPrTct|dkrt|Sddfd }dfd }t|}tt ||}t t t|tt|g|S)NrRFc3Kdyw)NTr) first_stoppedsr first_tailzzip_strict..first_tailhs $ sc3xKs d}t|tjD]}d}t|yw)Nz$zip_strict: first iterable is longerz%zip_strict: first iterable is shorter)rr from_iterable)r(rrrests rzip_tailzzip_strict..zip_tailosB$@C$S/),,T2AAC$S/)s7:)rr)rkzipiterrnextrjmap) iterablesrr iterables_itfirstrrs @@r zip_strictrasp9~!I&!M   ?L$|,jl;ED,/0DU*T*HJ7 7rc.t||jSr)r! RangeIndex)rrs r_is_range_indexrs c+66 77rc|j}t||xr:|jdk(xr)|jt |k(xr|j dk(S)NrrO)rrstartstoprkstep)native_frame_or_seriesrrs rrrsW # ( (E/0  KK1   JJ#e* $  JJ!O rc Rtd|}|j}t|r:|j|jj |j |i|St|r:|j|jj |j |i|S|S)aWConvert columns or series to the best possible dtypes using dtypes supporting ``pd.NA``, if df is pandas-like. Arguments: obj: DataFrame or Series. *args: Additional arguments which gets passed through. **kwargs: Additional arguments which gets passed through. Returns: Same type as input. Notes: For non-pandas-like inputs, this is a no-op. Also, `args` and `kwargs` just get passed down to the underlying library as-is. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> import numpy as np >>> df_pd = pd.DataFrame( ... { ... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")), ... "b": pd.Series([True, False, np.nan], dtype=np.dtype("O")), ... } ... ) >>> df = nw.from_native(df_pd) >>> nw.to_native( ... nw.maybe_convert_dtypes(df) ... ).dtypes # doctest: +NORMALIZE_WHITESPACE a Int32 b boolean dtype: object r) rrr4rrrconvert_dtypesr5r)rrmkwargsrrs rmaybe_convert_dtypesrsH5#G""$J +&&  $ $ 1 1) ))4:6:   Z(&&  % % 2 2) ))4:6:   Nrcv|dvr|S|dvr|dz S|dvr|dz S|dvr|dz S|dvr|d z Sd |}t|) zScale size in bytes to other size units (eg: "kb", "mb", "gb", "tb"). Arguments: sz: original size in bytes unit: size unit to convert into Returns: Integer or float. >brw>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got r)szunitr(s r scale_bytesrss ~  ""Dy ""G| ""G| ""G| Gx PC S/rcddlm}|jjj}|j}d}t ||r;t |j |jr|jjd}|S|j |jk(rd}|S|j |jk7rd}|S|j}|j}|jr8|jdkr%td|j j dk(}|S|j#r!t%|j&j(}|S|j+r0dd lm}||j0xr|j0j(}|S) aReturn whether indices of categories are semantically meaningful. This is a convenience function to accessing what would otherwise be the `is_ordered` property from the DataFrame Interchange Protocol, see https://data-apis.org/dataframe-protocol/latest/API.html. - For Polars: - Enums are always ordered. - Categoricals are ordered if `dtype.ordering == "physical"`. - For pandas-like APIs: - Categoricals are ordered if `dtype.cat.ordered == True`. - For PyArrow table: - Categoricals are ordered if `dtype.type.ordered == True`. Arguments: series: Input Series. Returns: Whether the Series is an ordered categorical. Examples: >>> import narwhals as nw >>> import pandas as pd >>> import polars as pl >>> data = ["x", "y"] >>> s_pd = pd.Series(data, dtype=pd.CategoricalDtype(ordered=True)) >>> s_pl = pl.Series(data, dtype=pl.Categorical(ordering="lexical")) Let's define a library-agnostic function: >>> @nw.narwhalify ... def func(s): ... return nw.is_ordered_categorical(s) Then, we can pass any supported library to `func`: >>> func(s_pd) True >>> func(s_pl) False r)InterchangeSeriesF is_orderedT)rO zpl.Categoricalphysical) is_dictionary)narwhals._interchange.seriesrrrrr!dtype Categoricalrdescribe_categoricalr rrdr3rrorderingr/rMcatorderedr?narwhals._arrow.utilsrr)rrrrresultrrers ris_ordered_categoricalr saT?  % % . . 5 5F((IF)./J f((5!!66|D& M%  $" M! ++ + M!!#$$ >>  5 5 7' A*FLL9BBjPF M  "&**,,-F M __  ;"6;;/GFKK4G4GF Mrc:d}t|dt||S)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versionsz1.13.0r)n_bytesr)r"generate_temporary_column_name)rrr(s rgenerate_unique_tokenr%s% ?cH5 )'7 KKrcrd} dt|dz }||vr|S|dz }|dkDrd|d|}t|5)aGenerates a unique column name that is not present in the given list of columns. It relies on [python secrets token_hex](https://docs.python.org/3/library/secrets.html#secrets.token_hex) function to return a string nbytes random bytes. Arguments: n_bytes: The number of bytes to generate for the token. columns: The list of columns to check for uniqueness. Returns: A unique token that is not present in the given list of columns. Raises: AssertionError: If a unique token cannot be generated after 100 attempts. Examples: >>> import narwhals as nw >>> columns = ["abc", "xyz"] >>> nw.generate_temporary_column_name(n_bytes=8, columns=columns) not in columns True rnwrOdzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr%)rrcountertokenr(s rrr0sm,G Yw{+,-  L1  S=*L 3 !% % rc|s-tt|jj|St|}t ||jx}r||S)N) available)rjsetr intersectioncheck_columns_exist)framesubsetrto_droperrors rparse_columns_to_dropr WsO C &33F;<<6lG#Gu}}EEuE NrcHt|txrt|t Sr)r!r r)sequences ris_sequence_but_not_strr#bs h ) K*Xs2K.KKrcBt|txr|tdk(Sr)r!slicers r is_slice_noner'fs c5 ! 8cU4[&88rct|xr3t|dkDxrt|dtxst|dk(xs%t |xst |xs t |SNr)r#rkr!r}r3r1is_compliant_series_intr&s ris_sized_multi_index_selectorr+jsl $C ( Pc(Q,::c!fc#:NCA  ( ! %  ( "# &  ( #3 'rcft|xs%t|xst|xs t|Sr)r#r2r0is_compliant_seriesr&s ris_sequence_liker.xs: $ $ S ! $ c " $ s # rc t|txrrt|jtxsVt|jtxs:t|j txr|jduxr|jduSr)r!r%rr}rrr&s ris_slice_indexr0sh c5 ! 399c" R chh $ R sxx % P#))t*; PD@Prc"t|tSr)r!ranger&s ris_ranger3s c5 !!rcZtt|txrt|t Sr)rMr!r}r&s ris_single_index_selectorr5s#  3$BZT-B)B CCrcLt|xst|xs t|Sr)r5r+r0r&s ris_index_selectorr7s+ !%  ( -  # rc^tt|txr|xrt|d|Sr))rMr!rj)rtps r is_list_ofr:s)  3%H#H*SVR2H IIrcxtt|xr%tt|dx}xr t ||Sr)rMr#rrr!)rr9rs ris_sequence_ofr<s> $ "49d+ +U " ub ! rcL|||}|S||| }|S|| |Sd}t|)Nz,Cannot pass both `strict` and `pass_through`r)rrpass_through_defaultr(s rvalidate_strict_and_pass_thoughr?s_ ~,.+     4!z  L4  =orr{F) warn_versionrequiredcdfd }|S)a8Decorator to transition from `native_namespace` to `backend` argument. Arguments: warn_version: Emit a deprecation warning from this version. required: Raise when both `native_namespace`, `backend` are `None`. Returns: Wrapped function, with `native_namespace` **removed**. c6tdfd }|S)Nc|jdd}|jdd}||rd}t||}n2|| d}t|||rdjd}t|||d<|i|S)Nr"rz`native_namespace` is deprecated, please use `backend` instead. Note: `native_namespace` will remain available in `narwhals.stable.v1`. See https://narwhals-dev.github.io/narwhals/backcompat/ for more information. rz0Can't pass both `native_namespace` and `backend`z `backend` must be specified in `z`.)popr"rr)rmkwdsr"rr(fnrAr@s rwrapperz=deprecate_native_namespace..decorate..wrappershhy$/G#xx(:DA +j .cLI*!-'2EH o%!)go(8 RH o%%DOt$t$ $r)rmP.argsrFP.kwargsrr)r)rGrHrAr@s` rdecoratez,deprecate_native_namespace..decorates r %  %*r)rGCallable[P, R]rrLr)r@rArKs`` rdeprecate_native_namespacerMs2 Orct|tdt|ttdd|dkr d}t||(|dkr d}t|||kDr d}t |||fS|}||fS)N window_size param_name min_samplesrOz+window_size must be greater or equal than 1z+min_samples must be greater or equal than 1z6`min_samples` must be less or equal than `window_size`) ensure_typer}rrr8)rOrRr(s r_validate_rolling_argumentsrTs S]; S$t*GQ;o ??CS/ !  $JC', ,  ##"  ##rc  tjj}|j j}td|D}|dz|krt|t|}dd|zd}|t|z }|dd |dzz|d |dz|dzzzd z }|dd |zd z }||z dz}||z dz||z dzz} |D]$} |dd |z| d | |zt| z zd z }&|d d|zd z }|Sdt|z } dddd | dzz|d | dz| dzzzddd S#t$r#t tj dd}Y:wxYw)NCOLUMNSPc32K|]}t|ywr)rk)rlines rrz generate_repr..s>3t9>rRu┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorr}getenv expandtabs splitlinesmaxrk) header native_reprterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrarYdiffs r generate_reprrqs7--/77))+668L>>>!~-%s6{3uv~&e,F + Ac\Q./0 PQ@QT`cdTd@d9e8ffijjAcVn%S)) 00Q6 ..14AQ8QUV7VV   kD #-.tfSIHX.,s#LAaS1#V,Lsz"Expected unique column names, got:)rkr collectionsrwrjoinr7)rrwrryr duplicatesr(s rcheck_column_names_are_uniquer}&s 7|s3w<((''"'.}}@tq!!a%ad@ @ggL9I9I9KLL23%8S!!)As  BBc|hdnt|tr|hn t|}|dhn>t|ttfr t|hn|Dchc]}| t|ndc}}||fScc}w)N>smsnsus)r!rrr ) time_unit time_zone time_unitstz time_zoness r_parse_time_unit_and_time_zoner1s    i %[ ^     i#x 1)n .fn\s r)rrrrr)rrGs` rpassthrough_column_namesr[s Irc4t}t||||uSr)objectr)rattrsentinels r_hasattr_staticrbsxH #tX .h >>rct|dS)N__narwhals_dataframe__rr&s ris_compliant_dataframergs 3 8 99rct|dS)N__narwhals_lazyframe__rr&s ris_compliant_lazyframerrs 3 8 99rct|dS)N__narwhals_series__rr&s rr-r-xs 3 5 66rcPt|xr|jjSr)r-r is_integerr&s rr*r*~s! s # > (<(<(>>rct|dS)N__narwhals_expr__)hasattrr&s ris_compliant_exprrs 3+ ,,rc|tjtjtjtjtj hvS)z.Return True if `impl` allows eager operations.)rr r r rrres ris_eager_allowedrsA   rcd|tjtjtjhvS)z4Return True if `LazyFrame.collect(impl)` is allowed.)rr rrrs rcan_lazyframe_collectrs& N))>+@+@.BXBXY YYrc|tjtjtjtjtj tj tjhvS)z1Return True if `DataFrame.lazy(impl)` is allowed.)rrrrrrrrrs ris_lazy_allowedrsS && rct|dS)Nrrr&s rhas_native_namespacers 3 6 77rct|dS)N__arrow_c_stream__rr&s rsupports_arrow_c_streamrs 3 4 55rcHfd|D}tt||S)aORemap join keys to avoid collisions. If left keys collide with the right keys, append the suffix. If there's no collision, let the right keys be. Arguments: left_on: Left keys. right_on: Right keys. suffix: Suffix to append to right keys. Returns: A map of old to new right keys. c36K|]}|vr|n|ywrr)rkeyleft_onsuffixs rrz(_remap_full_join_keys..s*8;C7N3%x3r)dictr)rright_onrright_keys_suffixeds` ` r_remap_full_join_keysrs( ?G H12 33rctdrV|jjjdj}|j j ||jSdt|d}t|)zGuards `ArrowDataFrame.from_arrow` w/ safer imports. Arguments: data: Object which implements `__arrow_c_stream__`. context: Initialized compliant object. Returns: A PyArrow Table. r)contextzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type r) rrrr#r _dataframe from_arrowrruModuleNotFoundError)datarrr(s r_into_arrow_tablersp    ' ' 4 4Y ? I I}}''b'9@@@ NObcgOhNkkl mC c ""rc|S)aVisual-only marker for unstable functionality. Arguments: fn: Function to decorate. Returns: Decorated function (unchanged). Examples: >>> from narwhals._utils import unstable >>> @unstable ... def a_work_in_progress_feature(*args): ... return args >>> >>> a_work_in_progress_feature.__name__ 'a_work_in_progress_feature' >>> a_work_in_progress_feature(1, 2, 3) (1, 2, 3) r)rGs runstablers ( Irc.tfddD S)aDetermines if a datetime format string is 'naive', i.e., does not include timezone information. A format is considered naive if it does not contain any of the following - '%s': Unix timestamp - '%z': UTC offset - 'Z' : UTC timezone designator Arguments: format: The datetime format string to check. Returns: bool: True if the format is naive (does not include timezone info), False otherwise. c3&K|]}|v ywrr)rxformats rrz#_is_naive_format..s:11;:s)z%sz%zZ)any)rs`r_is_naive_formatrs:(9:: ::rcZeZdZdZd d dZd dZd dZ d d dZddZe ddZ y)not_implementedaMark some functionality as unsupported. Arguments: alias: optional name used instead of the data model hook [`__set_name__`]. Returns: An exception-raising [descriptor]. Notes: - Attribute/method name *doesn't* need to be declared twice - Allows different behavior when looked up on the class vs instance - Allows us to use `isinstance(...)` instead of monkeypatching an attribute to the function Examples: >>> from narwhals._utils import not_implemented >>> class Thing: ... def totally_ready(self) -> str: ... return "I'm ready!" ... ... not_ready_yet = not_implemented() >>> >>> thing = Thing() >>> thing.totally_ready() "I'm ready!" >>> thing.not_ready_yet() Traceback (most recent call last): ... NotImplementedError: 'not_ready_yet' is not implemented for: 'Thing'. ... >>> isinstance(Thing.not_ready_yet, not_implemented) True [`__set_name__`]: https://docs.python.org/3/reference/datamodel.html#object.__set_name__ [descriptor]: https://docs.python.org/3/howto/descriptor.html Nc||_yr)_alias)raliass r__init__znot_implemented.__init__&s #( rcfdt|jd|jd|jS)N: r)rr _name_owner_namers r__repr__znot_implemented.__repr__+s14:&&'s4+;+;*) rrrrrrrrrrNr$rrrrrsU"H( K. PT 4 =L   %  ( (rrc(|d|d}t|)Nz is not implemented for: z. If you would like to see this functionality in `narwhals`, please open an issue at: https://github.com/narwhals-dev/narwhals/issues)NotImplementedError)whatrr(s rrrSs, (+C73S S c ""rc\eZdZUdZded<ded<ed d dZed dZddZ dd Z y )requiresa#Method decorator for raising under certain constraints. Attributes: _min_version: Minimum backend version. _hint: Optional suggested alternative. Examples: >>> from narwhals._utils import requires, Implementation >>> class SomeBackend: ... _implementation = Implementation.PYARROW ... _backend_version = 20, 0, 0 ... ... @requires.backend_version((9000, 0, 0)) ... def really_complex_feature(self) -> str: ... return "hello" >>> backend = SomeBackend() >>> backend.really_complex_feature() Traceback (most recent call last): ... NotImplementedError: `really_complex_feature` is only available in 'pyarrow>=9000.0.0', found version '20.0.0'. r _min_versionr_hintcD|j|}||_||_|S)zMethod decorator for raising below a minimum `_backend_version`. Arguments: minimum: Minimum backend version. hint: Optional suggested alternative. )__new__rr)rminimumhintrs rrJzrequires.backend_versionvs&kk#"  rc2djd|DS)Nrc3"K|]}| ywrr)rds rrz,requires._unparse_version..s811#8s )r{rIs r_unparse_versionzrequires._unparse_versionsxx8888rc @|j|jk\ry|j}|j}|j |j}|j |j}d|d|d|d|d }|j r|d|j }t |)N`z` is only available in 'z>=z', found version r )rr _wrapped_namerrrr)rrmethodr"rfoundr(s r_ensure_versionzrequires._ensure_versions  $ $(9(9 9 ##**''(9(9:%%h&?&?@&1'"WIEVW\V__`a ::EDJJ<(C!#&&rcVj_tdfd }|S)Nc>j||g|i|Sr)r)rrmrFrGrs rrHz"requires.__call__..wrappers&   *h... .r)rrrmrIrFrJrr)rrr)rrGrHs`` rrzrequires.__call__s,[[ r /  / rN)r{)rrrrrr>)rJrrr)rrrr)rG_Method[_ContextT, P, R]rr) rrrrrrNrJ staticmethodrrrrrrrr\sD,"! J  99 ' rrc|j|j|jnd}|j|j|jdznd}|j}|||fS)NrO)rrrr) str_slicerrrrs rconvert_str_slice_to_int_slicersZ/8oo.IGMM)// *tE090J7== (1 ,PTD >>D 4 rcdfd }|S)zSteal the class-level docstring from parent and attach to child `__init__`. Returns: Decorated constructor. Notes: - Passes static typing (mostly) - Passes at runtime c|jdk(r+tttrt|_|Sdt jd|j d}t|)Nrz`@zL` is only allowed to decorate an `__init__` with a class-level doc. Method: z Parent: )rrrrr inherit_docrrv) init_childr( tp_parents rrKzinherit_doc..decoratesp   * ,DOT1R!' !2J  %%&'!..12 m % nr)r _Constructor[_T, P, R2]rr r)r rKs` rrrs  Orct|tr|n t|}|jdk7r |jnd}|d|jj dS)Nbuiltinsr{r)r!rrrlstrip)rr9modules rrurusL3%49B mmz9R]]rFXQr{{m $ + +C 00rrPc:t||sdjd|D}d|dt|}|rYd}t|}t |dkDrt|d}||d}d t |zd t |zz}|d ||d |}t |y ) aValidate that an object is an instance of one or more specified types. Parameters: obj: The object to validate. *valid_types: One or more valid types that `obj` is expected to match. param_name: The name of the parameter being validated. Used to improve error message clarity. Raises: TypeError: If `obj` is not an instance of any of the provided `valid_types`. Examples: >>> from narwhals._utils import ensure_type >>> ensure_type(42, int, float) >>> ensure_type("hello", str) >>> ensure_type("hello", int, param_name="test") Traceback (most recent call last): ... TypeError: Expected 'int', got: 'str' test='hello' ^^^^^^^ >>> import polars as pl >>> import pandas as pd >>> df = pl.DataFrame([[1], [2], [3], [4], [5]], schema=[*"abcde"]) >>> ensure_type(df, pd.DataFrame, param_name="df") Traceback (most recent call last): ... TypeError: Expected 'pandas.core.frame.DataFrame', got: 'polars.dataframe.frame.DataFrame' df=polars.dataframe.frame.DataFrame(...) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ z | c32K|]}t|ywr)ru)rr9s rrzensure_type..sL"1"5LrZz Expected z, got: z (z(...)=r\^rN)r!r{rureprrkrv) rrQ valid_typestp_namesr(left_padvalassign underlines rrSrSsB c; '::L LL(W-@-E,HI Hs)C3x"},S12%8 z*Q/Fs6{*sSX~>IEF8C59+6Cn (rc(eZdZdZddZddZddZy) _DeferredIterablezLStore a callable producing an iterable to defer collection until we need it.c||_yr _into_iter)r into_iters rrz_DeferredIterable.__init__s 6?rc#@K|jEd{y7wrrrs r__iter__z_DeferredIterable.__iter__s??$$$s c\|j}t|tr|St|Sr)r r!rp)rits rto_tuplez_DeferredIterable.to_tuples& __ E*r9b 9rN)r!zCallable[[], Iterable[_T]]rr)rz Iterator[_T])rztuple[_T, ...])rrrrrr#r&rrrrrsV@%:rr@cJ|rdj|g|n|}t|S)Nr)r{r)rnestedrs rdeep_attrgetterr*s%(.388TOFO $DD d rc&t|g||S)z+Perform a nested attribute lookup on `obj`.)r*)rname_1r)s r deep_getattrr- s +?6 +F +C 00rc eZdZy) CompliantN)rrrrrrr/r/srr/c"eZdZdZeddZy)NarwhalsaMinimal *Narwhals-level* protocol. Provides access to a compliant object: obj: Narwhals[NativeT_co]] compliant: Compliant[NativeT_co] = obj._compliant Which itself exposes: implementation: Implementation = compliant.implementation native: NativeT_co = compliant.native This interface is used for revealing which `Implementation` member is associated with **either**: - One or more [nominal] native type(s) - One or more [structural] type(s) - where the true native type(s) are [assignable to] *at least* one of them These relationships are defined in the `@overload`s of `_Implementation.__get__(...)`. [nominal]: https://typing.python.org/en/latest/spec/glossary.html#term-nominal [structural]: https://typing.python.org/en/latest/spec/glossary.html#term-structural [assignable to]: https://typing.python.org/en/latest/spec/glossary.html#term-assignable cyrrrs r _compliantzNarwhals._compliant0s36rN)rzCompliant[NativeT_co])rrrrrr3rrrr1r1s066rr1cjeZdZdZddZeddZeddZeddZeddZe ddZeddZe dd Zedd Ze dd Zedd Zedd Ze d dZed!dZe d"dZed#dZd$dZy)%_ImplementationzDescriptor for matching an opaque `Implementation` on a generic class. Based on [pyright comment](https://github.com/microsoft/pyright/issues/3071#issuecomment-1043978070) c||_yr)rrs rrz_Implementation.__set_name__:s ! rcyrrrs rrz_Implementation.__get__=UXrcyrrrs rrz_Implementation.__get__?r8rcyrrrs rrz_Implementation.__get__ASVrcyrrrs rrz_Implementation.__get__CQTrcyrrrs rrz_Implementation.__get__Esrcyrrrs rrz_Implementation.__get__Ir;rcyrrrs rrz_Implementation.__get__Ks25rcyrrrs rrz_Implementation.__get__Or8rcyrrrs rrz_Implementation.__get__Qsrcyrrrs rrz_Implementation.__get__Ur=rcyrrrs rrz_Implementation.__get__Wr=rcyrrrs rrz_Implementation.__get__Ys.1rcyrrrs rrz_Implementation.__get__^sKNrcyrrrs rrz_Implementation.__get__`rrcyrrrs rrz_Implementation.__get__dr=rc6||S|jjSr)r3rrs rrz_Implementation.__get__fs'tPX-@-@-P-PPrN)r type[Any]rrrr)rzNarwhals[_NativePolars]rrrrg)rzNarwhals[_NativePandas]rrrre)rzNarwhals[_NativeModin]rrrrd)rzNarwhals[_NativeCuDF]rrrr])rzNarwhals[_NativePandasLike]rrrrf)rzNarwhals[_NativeArrow]rrrr\)rz6Narwhals[_NativePolars | _NativeArrow | _NativePandas]rrrz&_PolarsImpl | _PandasImpl | _ArrowImpl)rzNarwhals[_NativeDuckDB]rrrr_)rzNarwhals[_NativeSQLFrame]rrrrj)rzNarwhals[_NativeDask]rrrr^)rzNarwhals[_NativeIbis]rrrra)rz0Narwhals[_NativePySpark | _NativePySparkConnect]rrrz"_PySparkImpl | _PySparkConnectImpl)rrrztype[Narwhals[Any]]rr>)rzDataFrame[Any] | Series[Any]rrrr`)rzLazyFrame[Any]rrrrb)rzNarwhals[Any] | Nonerrrr)rrrrrr rrrrr5r54s| "XX XX VV TT 3rMrrM)r@rrArMrz*Callable[[Callable[P, R]], Callable[P, R]])rOr}rRz int | Nonerztuple[int, int])rfrrgrrr)rCollection[str]rrcrzColumnNotFoundError | None)rrcrr)rz$TimeUnit | Iterable[TimeUnit] | Nonerz7str | timezone | Iterable[str | timezone | None] | Nonerz%tuple[Set[TimeUnit], Set[str | None]]) rrorrurz Set[TimeUnit]rzSet[str | None]rrM)rrrr)rrrr_rr)rrrzEvalNames[Any])rrrrrrM)rz\CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co] | Anyrz^TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co]])rzJCompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co] | AnyrzLTypeIs[CompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co]])rz'CompliantSeries[NativeSeriesT_co] | Anyrz)TypeIs[CompliantSeries[NativeSeriesT_co]])rzECompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co] | AnyrzGTypeIs[CompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co]])rerrzTypeIs[_EagerAllowedImpl])rerrzTypeIs[_LazyFrameCollectImpl])rerrzTypeIs[_LazyAllowedImpl])rrrzTypeIs[SupportsNativeNamespace])rrrzTypeIs[ArrowStreamExportable])rrcrrcrrrzdict[str, str])rrXrrrpa.Table)rGrrr)rrrrM)rrrrrr)rrrrrz"tuple[int | None, int | None, Any])r zCallable[P, R1]rzr?r@narwhals._compliantrArBrCrDrErFnarwhals._compliant.typingrGrHrIrrJrKrLrMrNrOrPrQrRrSrTrUrVnarwhals._translaterWrXrYnarwhals._typingrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrrlrmrrorrqnarwhals.typingrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r rrrrrrrrr[r&r'rJrnrrrlrcrrrrrrrrsys version_inforrrrr rrr r#r'r+r.r0r3r5r7r:r<r?rMrTrqrr}rrrrrrrrr-r*rrrrrrrrrrrrrrrrurSrr*r-r/r1r5rQrVrrrr~s " XX66$*   &:<&[Z# YXZY&8%&&%( 'ininfSk&Q RN %.C %.C %.C %.C %.C %.C %.C %3 4C#A A B B8RxR00  T] \T 2 48 K~ 6 ==< i<  HZ(    x .   H -X- JHJ +^X(/8 42H 4IdIXM%ZM%b9)EF""F:4Z : 6 ).M""$9 @ < D 2&&>Q S*L" $,     -5     ""$?"" "  ..-H.(. .  (($J("( (  ::-S:4: :  ..$U.(. .  FFCFAF F  44N4/4 4  RRNRMR R  ::Y:5: :  Y  @@@ ; @ @    " #3  \ \K\\~!L,0VEI V V(V B V  Vr/dT*J 7"S.  8<8 9 MP   2 2 $20:22j0FRL L)LL$&N #0@DL9   H  2"D YJ     &&&)-&/&R$$#-$$0< .=""3"F"+"*     .; IX   M? : :  :: S:Q: 7 07.7 ? 0?.? - N-L- Z 864 4(74AD44,#&.;$O(O(d#@@F$1'A61 IK,^ : : 2 1 *4hz6J 7x #7:3Q3Qlr