o L¾±hqã@s 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!r¯ddlmHZHddlImJZJddlKZLddlMZNddlOZPddlQmRZRmSZSmTZTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZambZbddlcmdZdddlemfZfmgZgmhZhddlimjZjmkZkmlZlmmZmmnZnddlompZpmqZqddlrmsZsddltmuZuddlvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZm€Z€mZm‚Z‚mƒZƒm„Z„m…Z…e†Z‡deˆd<e'd e(eqe"epe"eue"fd!Z‰e'd"ƒZŠe'd#ƒZ‹e'd$ƒZŒe'd%ƒZe'd&ƒZŽe'd'ƒZe'd(ƒZe'd)d*d!Z‘eTd+ƒZ’e'd,ƒZ“e'd-ƒZ”e'd.ƒZ•Gd/d0„d0e&ƒZ–Gd1d2„d2e&ƒZ—Gd3d4„d4e&ƒZ˜e'd5ƒZ™e'd6d7d8Zše'd9d7d8Z›e'd:d;d!ZœdZždeˆd?<Gd@dA„dAe&ešƒZŸGdBdC„dCe&e›ƒZ GdDdE„dEe&ƒZ¡GdFdG„dGe&ƒZ¢GdHdI„dIe&ƒZ£GdJdK„dKe£e¢e&ƒZ¤GdLd;„d;e¡e¤e&ƒZ¥GdMdN„dNe£e&ƒZ¦GdOdP„dPeƒZ§GdQdR„dRe,ƒZ¨e¨j©dSe¨jªdTe¨j«dUe¨j¬dVe¨j­dWe¨j®dWe¨j¯dXe¨j°dYe¨j±dZe¨j²d[e¨j³d\i Z´d]eˆd^<e¨j°d_e¨jªd`e¨j­dae¨j®dbiZµdceˆdd< ededfd¥dkdl„ƒZ¶ed¦dodp„ƒZ·d§dtdu„Z¸d¨dwdx„Z¹d©d{d|„Zºdªdd€„Z»e*d«d†d‡„ƒZ¼e*d¬dŠd‡„ƒZ¼e*d­dd‡„ƒZ¼e*d®dd‡„ƒZ¼e*d¯d’d‡„ƒZ¼e*d°d”d‡„ƒZ¼e*d±d—d‡„ƒZ¼e*d²d™d‡„ƒZ¼e*d³dœd‡„ƒZ¼e*d´džd‡„ƒZ¼e*dµd¡d‡„ƒZ¼e*d¶d£d‡„ƒZ¼e*d·d¦d‡„ƒZ¼e*d¸d¨d‡„ƒZ¼e*d¹d«d‡„ƒZ¼dºd¬d‡„Z¼d»d°d±„Z½d¼dµd¶„Z¾d½dºd»„Z¿ d¾dd¼œd¿dÁd„ZÀdÀdÃdÄ„ZÁe!r;eeÂd7dÅZÃnddlÄZÄeÄjÅdÆkrLeeÂd7dÅZÃndÁdÉdÊ„ZÃdÂdÍd΄ZÆdÃdÑdÒ„ZÇdÄdÕdÖ„ZÈdÅdÜdÝ„ZÉdÆdàdá„ZÊdÇdådæ„ZËdÇdçdè„ZÌdÈdîdï„ZÍdÉdódô„ZÎdÊdöd÷„ZÏdËdùdú„ZÐdÌdüdý„ZÑdÍdÿd„ZÒdÎdd„ZÓdÏdd„ZÔdÐdd „ZÕdÑd d „ZÖdÒdd„Z×dÓdd„ZØdddœdÔdd„ZÙdÕd!d"„ZÚdÖd%d&„ZÛd×d*d+„ZÜdØd,d-„ZÝdÙd3d4„ZÞdÚd=d>„ZßdÛd@dA„ZàdÜdCdD„ZádÝdFdG„ZâdÞdIdJ„ZãdßdMdN„ZädàdQdR„ZådádUdV„ZædádWdX„Zçdâd[d\„Zèdãd_d`„Zédädbdc„Zêdådedf„Zëdædhdi„Zìdçdkdl„Zídèdqdr„Zîdédwdx„Zïdêdzd{„Zðdëd}d~„ZñGdd€„d€ƒZòdìd„d…„ZóGd†d‡„d‡ƒZôdíd‹dŒ„Zõdîdd‘„Zödïd“d”„Z÷dd•œdðd™dš„ZøGd›dœ„dœe$e™ƒZùeddfdñd d¡„ƒZúdòd£d¤„ZûdS(óé)Ú annotationsN)Ú CollectionÚ ContainerÚIterableÚIteratorÚMappingÚSequence)Útimezone)ÚEnumÚauto)ÚcacheÚ lru_cacheÚpartialÚwraps)Ú find_spec)Úgetattr_staticÚgetdoc)Úchain)Ú attrgetter)Ú token_hex) Ú TYPE_CHECKINGÚAnyÚCallableÚGenericÚLiteralÚProtocolÚTypeVarÚUnionÚcastÚoverload)Ú NoAutoEnum)Úissue_deprecation_warning)Ú assert_neverÚ deprecated)Úget_cudfÚget_dask_dataframeÚ get_duckdbÚget_ibisÚ get_modinÚ get_pandasÚ get_polarsÚ get_pyarrowÚget_pyspark_connectÚget_pyspark_sqlÚ get_sqlframeÚis_narwhals_seriesÚis_narwhals_series_intÚis_numpy_array_1dÚis_numpy_array_1d_intÚis_pandas_like_dataframeÚis_pandas_like_series)ÚColumnNotFoundErrorÚDuplicateErrorÚInvalidOperationError)ÚSet)Ú ModuleType)Ú ConcatenateÚ LiteralStringÚ ParamSpecÚSelfÚ TypeAliasÚTypeIs)Ú CompliantExprÚCompliantExprTÚCompliantFrameTÚCompliantSeriesOrNativeExprT_coÚCompliantSeriesTÚNativeFrameT_coÚNativeSeriesT_co)Ú EvalNamesÚNativeLazyFrameT©Ú Namespace)ÚArrowStreamExportableÚIntoArrowTableÚToNarwhalsT_co)ÚBackendÚ IntoBackendÚ_DataFrameLazyImplÚ_EagerAllowedImplÚ_LazyFrameCollectImpl©Ú DataFrameÚ LazyFrame©ÚDType©ÚSeries)ÚCompliantDataFrameÚCompliantLazyFrameÚCompliantSeriesÚDTypesÚ IntoSeriesTÚMultiIndexSelectorÚSingleIndexSelectorÚSizedMultiIndexSelectorÚSizeUnitÚSupportsNativeNamespaceÚTimeUnitÚ_1DArrayÚ _SliceIndexÚ _SliceNameÚ _SliceNoner>ÚUnknownBackendNameÚFrameOrSeriesT)ÚboundÚ_T1Ú_T2Ú_T3Ú_T4Ú_T5Ú_T6Ú_T7Ú_FnzCallable[..., Any]ÚPÚRÚR1ÚR2c@óeZdZUded<dS)Ú_SupportsVersionÚstrÚ __version__N©Ú__name__Ú __module__Ú __qualname__Ú__annotations__©rrúP/var/www/html/Persson_Maskin/env/lib/python3.10/site-packages/narwhals/_utils.pyry~s ryc@seZdZd d dd„ZdS) Ú _SupportsGetNÚinstancerÚownerú Any | NoneÚreturncCódS©Nr)Úselfr„r…rrr‚Ú__get__‚sz_SupportsGet.__get__r‰)r„rr…r†r‡r)r}r~rr‹rrrr‚rƒsrƒc@óeZdZeddd„ƒZdS)Ú_StoresColumnsr‡ú Sequence[str]cCrˆr‰r©rŠrrr‚Úcolumns…óz_StoresColumns.columnsN)r‡rŽ)r}r~rÚpropertyrrrrr‚r„órÚ_TÚ NativeT_coT)Ú covariantÚ CompliantT_coÚ _ContextTÚ _FullContextz&Callable[Concatenate[_ContextT, P], R]Ú_Methodz Callable[Concatenate[_T, P], R2]Ú _Constructorc@óeZdZdZeddd„ƒZdS)Ú _StoresNativez’Provides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table r‡r•cCódS)zReturn the native object.Nrrrrr‚Únativešóz_StoresNative.nativeN)r‡r•)r}r~rÚ__doc__r’rŸrrrr‚r‘órc@rœ)Ú_StoresCompliantzÓProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame r‡r—cCrž)zReturn the compliant object.Nrrrrr‚Ú compliant©r z_StoresCompliant.compliantN)r‡r—)r}r~rr¡r’r¤rrrr‚r£ r¢r£c@rŒ)Ú_StoresBackendVersionr‡útuple[int, ...]cCrž)z#Version tuple for a native package.Nrrrrr‚Ú_backend_version°r z&_StoresBackendVersion._backend_versionN©r‡r¦)r}r~rr’r§rrrr‚r¥¯r“r¥c@rx)Ú_StoresVersionÚVersionÚ_versionNr|rrrr‚r©¶ó r©c@rx)Ú_StoresImplementationÚImplementationÚ_implementationNr|rrrr‚r­»r¬r­c@óeZdZdZdS)Ú_LimitedContextzEProvides 2 attributes. - `_implementation` - `_version` N©r}r~rr¡rrrr‚r±Àór±c@r°)r™z^Provides 3 attributes. - `_implementation` - `_backend_version` - `_version` Nr²rrrr‚r™Èr³c@seZdZdZddd„ZdS)ÚValidateBackendVersionz=Ensure the target `Implementation` is on a supported version.r‡ÚNonecCs|j ¡}dS)z½Raise if installed version below `nw._utils.MIN_VERSIONS`. **Only use this when moving between backends.** Otherwise, the validation will have taken place already. N)r¯r§)rŠÚ_rrr‚Ú_validate_backend_versionÔsz0ValidateBackendVersion._validate_backend_versionN)r‡rµ)r}r~rr¡r·rrrr‚r´Ñsr´c@sdeZdZeƒZeƒZeƒZeddd„ƒZeddd„ƒZ edd d „ƒZ edd d „ƒZ eddd„ƒZ dS)rªr‡útype[Namespace[Any]]cCóD|tjur ddlm}|S|tjurddlm}|Sddlm}|S)NrrI)rªÚV1Únarwhals.stable.v1._namespacerJÚV2Únarwhals.stable.v2._namespaceÚnarwhals._namespace)rŠÚ NamespaceV1Ú NamespaceV2rJrrr‚Ú namespaceâó     zVersion.namespacer]cCr¹)Nr)Údtypes)rªrºÚnarwhals.stable.v1rÃr¼Únarwhals.stable.v2Únarwhals)rŠÚ dtypes_v1Ú dtypes_v2rÃrrr‚rÃðrÂzVersion.dtypesútype[DataFrame[Any]]cCr¹)Nr©rT)rªrºrÄrTr¼rÅÚnarwhals.dataframe)rŠÚ DataFrameV1Ú DataFrameV2rTrrr‚Ú dataframeþrÂzVersion.dataframeútype[LazyFrame[Any]]cCr¹)Nr©rU)rªrºrÄrUr¼rÅrË)rŠÚ LazyFrameV1Ú LazyFrameV2rUrrr‚Ú lazyframe rÂzVersion.lazyframeútype[Series[Any]]cCr¹)NrrX)rªrºrÄrYr¼rÅÚnarwhals.series)rŠÚSeriesV1ÚSeriesV2rYrrr‚ÚseriesrÂzVersion.seriesN)r‡r¸)r‡r])r‡rÉ)r‡rÏ)r‡rÔ) r}r~rr rºr¼ÚMAINr’rÁrÃrÎrÓrØrrrr‚rªÝs     rªc@s"eZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z d@dd„ZedAdd„ƒZedBdd„ƒZedCdd„ƒZdDdd „ZdEd"d#„ZdEd$d%„ZdEd&d'„ZdEd(d)„ZdEd*d+„ZdEd,d-„ZdEd.d/„ZdEd0d1„ZdEd2d3„ZdEd4d5„ZdEd6d7„Z dEd8d9„Z!dEd:d;„Z"dFd=d>„Z#d?S)Gr®z?Implementation of native object (pandas, Polars, PyArrow, ...).ÚpandasÚmodinÚcudfÚpyarrowÚpysparkÚpolarsÚdaskÚduckdbÚibisÚsqlframezpyspark[connect]Úunknownr‡rzcCs t|jƒSr‰)rzÚvaluerrrr‚Ú__str__Eó zImplementation.__str__Úclsú type[Self]Únative_namespacer9cCsjtƒtjtƒtjtƒtjtƒtjt ƒtj t ƒtj t ƒtjtƒtjtƒtjtƒtjtƒtji }| |tj¡S)zŽInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. )r)r®ÚPANDASr(ÚMODINr$ÚCUDFr+ÚPYARROWr-ÚPYSPARKr*ÚPOLARSr%ÚDASKr&ÚDUCKDBr'ÚIBISr.ÚSQLFRAMEr,ÚPYSPARK_CONNECTÚgetÚUNKNOWN)rèrêÚmappingrrr‚Úfrom_native_namespaceHs õ z$Implementation.from_native_namespaceÚ backend_namecCs$z||ƒWStytjYSw)zžInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. )Ú ValueErrorr®r÷)rèrúrrr‚Ú from_string`s    ÿzImplementation.from_stringÚbackendú)IntoBackend[Backend] | UnknownBackendNamecCs,t|tƒr | |¡St|tƒr|S| |¡S)z¢Instantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. )Ú isinstancerzrür®rù)rèrýrrr‚Ú from_backendls ÿÿÿýûzImplementation.from_backendcCs4|tjur d}t|ƒ‚| ¡t ||j¡}t|ƒS)zCReturn the native namespace module corresponding to Implementation.z:Cannot return native namespace from UNKNOWN Implementation)r®r÷ÚAssertionErrorr§Ú_IMPLEMENTATION_TO_MODULE_NAMEröråÚ_import_native_namespace)rŠÚmsgÚ module_namerrr‚Úto_native_namespace}s z"Implementation.to_native_namespaceÚboolcCó |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 )r®rërrrr‚Ú is_pandas‡ó zImplementation.is_pandascCó|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 )r®rërìrírrrr‚Úis_pandas_like”s zImplementation.is_pandas_likecCr )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 )r®rïrôrõrrrr‚Ú is_spark_like¡s  ýzImplementation.is_spark_likecCr)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 )r®rðrrrr‚Ú is_polars²r zImplementation.is_polarscCr)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 )r®rírrrr‚Úis_cudf¿r zImplementation.is_cudfcCr)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 )r®rìrrrr‚Úis_modinÌr zImplementation.is_modincCr)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 )r®rïrrrr‚Ú is_pysparkÙr zImplementation.is_pysparkcCr)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 )r®rõrrrr‚Úis_pyspark_connectær z!Implementation.is_pyspark_connectcCr)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 )r®rîrrrr‚Ú is_pyarrowór zImplementation.is_pyarrowcCr)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 )r®rñrrrr‚Úis_daskr zImplementation.is_daskcCr)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 )r®ròrrrr‚Ú is_duckdb r zImplementation.is_duckdbcCr)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 )r®rórrrr‚Úis_ibisr zImplementation.is_ibiscCr)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 )r®rôrrrr‚Ú is_sqlframe'r zImplementation.is_sqlframer¦cCst|ƒS)zReturns backend version.©Úbackend_versionrrrr‚r§4szImplementation._backend_versionN©r‡rz)rèrérêr9r‡r®)rèrérúrzr‡r®)rèrérýrþr‡r®)r‡r9)r‡rr¨)$r}r~rr¡rërìrírîrïrðrñròrórôrõr÷ræÚ classmethodrùrürrr r r rrrrrrrrrrr§rrrr‚r®)s`        r®)éré)réé)éé )é )ré)réé)ièr©r)é)rérz(Mapping[Implementation, tuple[int, ...]]Ú MIN_VERSIONSzdask.dataframez modin.pandasz pyspark.sqlzpyspark.sql.connectzMapping[Implementation, str]ré)Úmaxsizerrzr‡r9cCsddlm}||ƒS)Nr)Ú import_module)Ú importlibr,)rr,rrr‚rPs rÚimplementationr¦c CsÌt|tƒs t|ƒ|tjurd}t|ƒ‚|}t ||j¡}t|ƒ}|  ¡r-ddl }|j }n|  ¡s5|  ¡r§s€ z parse_version..Ú.)rÿrzr{rHrIr<Úsplit)r3Ú version_strrrr‚r0™s r0Ú obj_or_clsÚtypeÚ cls_or_tupleútype[_T]úTypeIs[type[_T]]cCrˆr‰r©rPrRrrr‚Úisinstance_or_issubclassªr rVú object | typeúTypeIs[_T | type[_T]]cCrˆr‰rrUrrr‚rV°r útuple[type[_T1], type[_T2]]úTypeIs[type[_T1 | _T2]]cCrˆr‰rrUrrr‚rV¶r ú#TypeIs[_T1 | _T2 | type[_T1 | _T2]]cCrˆr‰rrUrrr‚rV¼r ú&tuple[type[_T1], type[_T2], type[_T3]]úTypeIs[type[_T1 | _T2 | _T3]]cCrˆr‰rrUrrr‚rVÂr ú/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]]cCrˆr‰rrUrrr‚rVÈr ú1tuple[type[_T1], type[_T2], type[_T3], type[_T4]]ú#TypeIs[type[_T1 | _T2 | _T3 | _T4]]cCrˆr‰rrUrrr‚rVÎr ú;TypeIs[_T1 | _T2 | _T3 | _T4 | type[_T1 | _T2 | _T3 | _T4]]cCrˆr‰rrUrrr‚rVÔóúddlm}t||ƒrt||ƒSt||ƒpt|tƒot||ƒS)NrrV)Únarwhals.dtypesrWrÿrQÚ issubclass)rPrRrWrrr‚rVs    ÿÚitemsú Iterable[Any]rµcs\ddlm‰m‰t‡fdd„|Dƒƒst‡fdd„|Dƒƒr dSddd„|Dƒ›}t|ƒ‚) NrrSc3ó|]}t|ˆƒVqdSr‰©rÿ©rJÚitemrÊrr‚rL'ó€z$validate_laziness..c3rsr‰rtrurÐrr‚rL(rwzGThe items to concatenate should either all be eager, or all lazy, got: cSsg|]}t|ƒ‘qSr)rQrurrr‚Ú +sz%validate_laziness..)rËrTrUÚallrA)rqrrrSr‚Úvalidate_laziness$sÿrzÚlhsÚrhsú-Series[Any] | DataFrame[Any] | LazyFrame[Any]cCsòddlm}ddlm}ddd „}td|ƒ}td|ƒ}tt|d d ƒ|ƒrLtt|d d ƒ|ƒrL||jjj ƒ||jjj ƒ|  |j  |jjj |jjj ¡¡Stt|d d ƒ|ƒr}tt|d d ƒ|ƒr}||jjj ƒ||j jj ƒ|  |j  |jjj |j jj ¡¡Stt|d d ƒ|ƒr®tt|d d ƒ|ƒr®||j jj ƒ||jjj ƒ|  |j   |j jj |jjj ¡¡Stt|d d ƒ|ƒrßtt|d d ƒ|ƒrß||j jj ƒ||j jj ƒ|  |j   |j jj |j jj ¡¡St|ƒt|ƒkr÷d t|ƒ›dt|ƒ›}t|ƒ‚|S)aÖAlign `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)ÚPandasLikeSeriesÚindexrr‡rµcSs|js d}t|ƒ‚dS)Nz'given index doesn't have a unique index)Ú is_uniquerû)r€rrrr‚Ú_validate_indexSsþz*maybe_align_index.._validate_indexÚ_compliant_frameNÚ_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )r€rr‡rµ)Únarwhals._pandas_like.dataframer~Únarwhals._pandas_like.seriesrrrÿÚgetattrrƒrŸr€Ú_with_compliantÚ _with_nativeÚlocr„r8rû)r{r|r~rr‚Úlhs_anyÚrhs_anyrrrr‚Úmaybe_align_index/s~ !     ÿþÿÿ ÿþÿÿÿ ÿþÿÿÿ ÿþÿÿÿrÚobjú-DataFrame[Any] | LazyFrame[Any] | Series[Any]r†cCs,td|ƒ}| ¡}t|ƒst|ƒr|jSdS)a¼Get 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_nativer3r4r€)rŽÚobj_anyÚ native_objrrr‚Úmaybe_get_indexŽs r“)r€Ú column_namesústr | list[str] | Noner€ú6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonecsòddlm‰td|ƒ}| ¡}|dur|durd}t|ƒ‚|s)|dur)d}t|ƒ‚|durAt|ƒr:‡fdd„|Dƒnˆ|d d }n|}t|ƒrS| |j |  |¡¡¡St |ƒrwdd l m }|red }t|ƒ‚||||j j d }| |j  |¡¡S|S)aÙSet 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©rrNz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedcsg|]}ˆ|dd‘qS)T©Ú pass_throughr)rJÚidxr—rr‚rxðóz#maybe_set_index..Tr˜)Ú set_indexz/Cannot set index using column names on a Series)r.)Únarwhals.translaterrrûr9r3rˆrƒr‰rœr4Únarwhals._pandas_like.utilsr„r¯)rŽr”r€Údf_anyr’rÚkeysrœrr—r‚Úmaybe_set_index²s> /  ÿ ýÿ ýr¡cCs†td|ƒ}| ¡}t|ƒr%| ¡}t||ƒr|S| |j |jdd¡¡St |ƒrA| ¡}t||ƒr4|S| |j  |jdd¡¡S|S)aýReset 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) rrr3Ú__native_namespace__Ú_has_default_indexrˆrƒr‰Ú reset_indexr4r„)rŽr‘r’rêrrr‚Úmaybe_reset_index s"  ÿ ÿr¦)Ústrict)rr!Ú iterablesúIterable[tuple[Any, ...]]cstt|ƒdkr t|ŽSd‰d ‡fdd„ }d ‡‡fdd„ }t|ƒ}tt|ƒ|ƒƒ}ttt|ƒƒ‰tt|gˆ¢RŽ|ƒƒS) NrFr‡rc3s d‰dS)NTrr)Ú first_stoppedrr‚Ú first_tailNs€zzip_strict..first_tailc3s0ˆs d}t|ƒ‚t ˆ¡D]}d}t|ƒ‚dS)Nz$zip_strict: first iterable is longerz%zip_strict: first iterable is shorter)rûrÚ from_iterable)rr¶©rªÚrestrr‚Úzip_tailUs€þzzip_strict..zip_tail)r‡r)r8ÚzipÚiterrÚnextr7Úmap)r¨r«r¯Ú iterables_itÚfirstrr­r‚Ú zip_strictGs  r¶rêúTypeIs[pd.RangeIndex]cCs t||jƒSr‰)rÿÚ RangeIndex)rŽrêrrr‚Ú_is_range_indexes r¹Únative_frame_or_seriesúpd.Series[Any] | pd.DataFramecCs2|j}t||ƒo|jdko|jt|ƒko|jdkS)Nrr)r€r¹ÚstartÚstopr8Ústep)rºrêr€rrr‚r¤is ÿ þür¤Úkwargsú bool | strcOsbtd|ƒ}| ¡}t|ƒr| |j |j|i|¤Ž¡¡St|ƒr/| |j |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) rrr3rˆrƒr‰Úconvert_dtypesr4r„)rŽr5r¿r‘r’rrr‚Úmaybe_convert_dtypesus $ÿÿÿÿrÂÚszrGÚunitrbú int | floatcCs^|dvr|S|dvr|dS|dvr|dS|dvr|dS|dvr&|d Sd |›}t|ƒ‚) zÍScale 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. >ÚbrB>ÚkbÚ kilobytesi>ÚmbÚ megabytesi>ÚgbÚ gigabytesi@>ÚtbÚ terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got ©rû)rÃrÄrrrr‚Ú scale_bytesªs  rÐrØú Series[Any]cCsêddlm}|jjj}|j}d}t||ƒr$t|j|jƒr$|jj d}|S|j|j kr.d}|S|j|jkr8d}|S|  ¡}|j }|  ¡rT| ¡dkrTtd|jƒjdk}|S| ¡r`t|jjƒ}|S| ¡rsdd lm}||jƒor|jj}|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)ré zpl.CategoricalÚphysical)Ú is_dictionary)Únarwhals._interchange.seriesrÒr„r«rÃrÿÚdtypeÚ CategoricalrŸÚdescribe_categoricalr rr.rr§rÚorderingr rÚcatÚorderedrÚnarwhals._arrow.utilsrÖrQ)rØrÒrÃr¤ÚresultrŸr1rÖrrr‚Úis_ordered_categoricalÂs6 *  ÿ  î ðóú ü ràÚn_bytesrúContainer[str]cCsd}t|ddt||dS)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versionsz1.13.0©r«)rár)r!Úgenerate_temporary_column_name)rárrrrr‚Úgenerate_unique_token sÿ  råcCsNd} dt|dƒ›}||vr|S|d7}|dkr&d|›d|›}t|ƒ‚q)aùGenerates 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 rTÚnwrédzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr)rárÚcounterÚtokenrrrr‚räsÿÿÿóräÚframeÚsubsetú Iterable[str]r§ú list[str]cCs:|s tt|jƒ |¡ƒSt|ƒ}t||jd}r|‚|S)N)Ú available)r7ÚsetrÚ intersectionÚcheck_columns_exist)rêrër§Úto_dropÚerrorrrr‚Úparse_columns_to_drop=s rôÚsequenceúSequence[_T] | AnyúTypeIs[Sequence[_T]]cCst|tƒo t|tƒ Sr‰)rÿrrz)rõrrr‚Úis_sequence_but_not_strHórøúTypeIs[_SliceNone]cCst|tƒo |tdƒkSr‰)rÿÚslice©rŽrrr‚Ú is_slice_noneLrùrýúCTypeIs[SizedMultiIndexSelector[Series[Any] | CompliantSeries[Any]]]cCsFt|ƒot|ƒdkrt|dtƒpt|ƒdkp"t|ƒp"t|ƒp"t|ƒS©Nr)rør8rÿrGr2r0Úis_compliant_series_intrürrr‚Úis_sized_multi_index_selectorPs$þüûùrú-TypeIs[Sequence[_T] | Series[Any] | _1DArray]cCs t|ƒpt|ƒpt|ƒpt|ƒSr‰)rør1r/Úis_compliant_seriesrürrr‚Úis_sequence_like^sÿþürúTypeIs[_SliceIndex]cCsBt|tƒo t|jtƒp t|jtƒp t|jtƒo |jduo |jduSr‰)rÿrûr¼rGr½r¾rürrr‚Úis_slice_indexis   ÿýrú TypeIs[range]cCs t|tƒSr‰)rÿÚrangerürrr‚Úis_rangeqrçr úTypeIs[SingleIndexSelector]cCstt|tƒo t|tƒ ƒSr‰)rrÿrGrürrr‚Úis_single_index_selectorusr úTTypeIs[SingleIndexSelector | MultiIndexSelector[Series[Any] | CompliantSeries[Any]]]cCst|ƒp t|ƒp t|ƒSr‰)r rrrürrr‚Úis_index_selectorys ÿýr ÚtpúTypeIs[list[_T]]cCs tt|tƒo|ot|d|ƒƒSrÿ)rrÿr7)rŽrrrr‚Ú is_list_ofƒs rcCs(tt|ƒott|ƒdƒ}ot||ƒƒSr‰)rrør²r±rÿ)rŽrrµrrr‚Úis_sequence_ofˆs ÿýrú bool | Noner™Úpass_through_defaultcCsT|dur |dur |}|S|dur|dur| }|S|dur$|dur$ |Sd}t|ƒ‚)Nz,Cannot pass both `strict` and `pass_through`rÏ)r§r™rrrrr‚Úvalidate_strict_and_pass_though‘sùûþrrFF)Ú warn_versionÚrequiredrrú*Callable[[Callable[P, R]], Callable[P, R]]csd‡‡fdd„ }|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**. ÚfnúCallable[P, R]r‡cstˆƒd ‡‡‡fdd„ ƒ}|S) Nr5úP.argsÚkwdsúP.kwargsr‡rucsž| dd¡}| dd¡}|dur!|dur!ˆrd}t|ˆd|}n#|dur/|dur/d}t|ƒ‚|durD|durDˆrDdˆj›d}t|ƒ‚||d<ˆ|i|¤ŽS)Nrýrêz×`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. rãz0Can't pass both `native_namespace` and `backend`z `backend` must be specified in `z`.)Úpopr!rûr})r5rrýrêr)rrrrr‚Úwrapper±s  ÿ z=deprecate_native_namespace..decorate..wrapper)r5rrrr‡ru)r)rr©rr©rr‚Údecorate°sz,deprecate_native_namespace..decorateN)rrr‡rr)rrr!rrr‚Údeprecate_native_namespace£s r"Ú window_sizeÚ min_samplesú int | Noneútuple[int, int]cCszt|tddt|ttdƒdd|dkrd}t|ƒ‚|dur7|dkr)d}t|ƒ‚||kr3d}t|ƒ‚||fS|}||fS)Nr#©Ú param_namer$rz+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_typerGrQrûr7)r#r$rrrr‚Ú_validate_rolling_argumentsÌsþr*ÚheaderÚ native_reprc Cs€zt ¡j}Wntytt dd¡ƒ}Ynw| ¡ ¡}tdd„|Dƒƒ}|d|kržt|t |ƒƒ}dd|›d}|t |ƒ}|d d |d›|›d |d|d›d 7}|d d |›d 7}||d}||d||d} |D]} |d d |›| ›d | |t | ƒ›d 7}qy|d d|›d7}|Sdt |ƒ} dd›dd | d›|›d | d| d›dd›d S)NÚCOLUMNSéPcsó|]}t|ƒVqdSr‰)r8)rJÚlinerrr‚rLêó€z generate_repr..ru┌u─uâ” ú|ú z| ú-uâ””u┘é'uu───────────────────────────────────────uâ” |u/| | Use `.to_native` to see native output | â””) ÚosÚget_terminal_sizerÚOSErrorrGÚgetenvÚ expandtabsÚ splitlinesÚmaxr8) r+r,Úterminal_widthÚ native_linesÚmax_native_widthÚlengthÚoutputÚ header_extraÚ start_extraÚ end_extrar0Údiffrrr‚Ú generate_repräs< ÿ   0 .  ÿÿÿýÿrFúCollection[str]rîúColumnNotFoundError | NonecCs"t|ƒ |¡}rt ||¡SdSr‰)rïÚ differencer5Ú'from_missing_and_available_column_names)rërîÚmissingrrr‚rñs ÿrñcCsht|ƒtt|ƒƒkr2ddlm}||ƒ}dd„| ¡Dƒ}d dd„| ¡Dƒ¡}d|›}t|ƒ‚dS) Nr)ÚCountercSsi|] \}}|dkr||“qSr&r©rJÚkrKrrr‚Ú sz1check_column_names_are_unique..rFcss&|]\}}d|›d|›dVqdS)z - 'z' z timesNrrMrrr‚rLs€$z0check_column_names_are_unique..z"Expected unique column names, got:)r8rïÚ collectionsrLrqÚjoinr6)rrLrèÚ duplicatesrrrr‚Úcheck_column_names_are_unique s  ùrSÚ time_unitú$TimeUnit | Iterable[TimeUnit] | NoneÚ time_zoneú7str | timezone | Iterable[str | timezone | None] | Noneú%tuple[Set[TimeUnit], Set[str | None]]cCsd|durhd£n t|tƒr|hnt|ƒ}|durdhnt|ttfƒr't|ƒhndd„|Dƒ}||fS)N>ÚsÚmsÚnsÚuscSs h|] }|dur t|ƒnd’qSr‰)rz)rJÚtzrrr‚Ú 's z1_parse_time_unit_and_time_zone..)rÿrzrïr )rTrVÚ time_unitsÚ time_zonesrrr‚Ú_parse_time_unit_and_time_zonesÿÿû ÿ  ÿ ûrarØrWrÃr]r_ú Set[TimeUnit]r`úSet[str | None]cCs2t||jƒo|j|vo|j|vpd|vo|jduS)NÚ*)rÿÚDatetimerTrV)rØrÃr_r`rrr‚Ú%dtype_matches_time_unit_and_time_zone,s ÿ ûrfrŽcCs|jSr‰©r)rêrrr‚Úget_column_names9srhÚnamescs‡fdd„|jDƒS)Ncsg|]}|ˆvr|‘qSrr)rJÚcol_name©rirr‚rx>r›z(exclude_column_names..rg)rêrirrkr‚Úexclude_column_names=srlúEvalNames[Any]csd‡fdd„ }|S)NÚ_framerr‡rŽcsˆSr‰r)rnrkrr‚rBr‘z$passthrough_column_names..fn)rnrr‡rŽr)rirrrkr‚Úpassthrough_column_namesAsroÚattrcCstƒ}t|||ƒ|uSr‰)Úobjectr)rŽrpÚsentinelrrr‚Ú_hasattr_staticHsrsú[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co] | Anyú]TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co]]cCó t|dƒS)NÚ__narwhals_dataframe__©rsrürrr‚Úis_compliant_dataframeMs ryúJCompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co] | AnyúLTypeIs[CompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co]]cCrv)NÚ__narwhals_lazyframe__rxrürrr‚Úis_compliant_lazyframeXó r}ú'CompliantSeries[NativeSeriesT_co] | Anyú)TypeIs[CompliantSeries[NativeSeriesT_co]]cCrv)NÚ__narwhals_series__rxrürrr‚r^r~rcCst|ƒo|j ¡Sr‰)rrØÚ is_integerrürrr‚rdsrúECompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co] | AnyúGTypeIs[CompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co]]cCrv)NÚ__narwhals_expr__)Úhasattrrürrr‚Úis_compliant_exprjr~r‡r1úTypeIs[_EagerAllowedImpl]cCs|tjtjtjtjtjhvS)z.Return True if `impl` allows eager operations.)r®rërìrírðrî©r1rrr‚Úis_eager_allowedpsûrŠúTypeIs[_LazyFrameCollectImpl]cCr )z4Return True if `LazyFrame.collect(impl)` is allowed.)r®rërðrîr‰rrr‚Úcan_lazyframe_collect{órŒúTypeIs[_DataFrameLazyImpl]cCs|tjtjtjtjhvS)z1Return True if `DataFrame.lazy(impl)` is allowed.)r®rñròrðrór‰rrr‚Úcan_dataframe_lazy€s ürúTypeIs[SupportsNativeNamespace]cCrv)Nr£rxrürrr‚Úhas_native_namespaceŠrçr‘úTypeIs[ArrowStreamExportable]cCrv)NÚ__arrow_c_stream__rxrürrr‚Úsupports_arrow_c_streamŽrçr”Úleft_onÚright_onÚsuffixúdict[str, str]cs"‡‡fdd„|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. c3s(|]}|ˆvr|›ˆ›n|VqdSr‰r)rJÚkey©r•r—rr‚rL¢s€ ÿz(_remap_full_join_keys..)Údictr°)r•r–r—Úright_keys_suffixedrršr‚Ú_remap_full_join_keys’s ÿrÚdatarLÚcontextúpa.TablecCsBtdƒr|jj d¡j}|jj||djSdt|ƒ›d}t |ƒ‚)zÛGuards `ArrowDataFrame.from_arrow` w/ safer imports. Arguments: data: Object which implements `__arrow_c_stream__`. context: Initialized compliant object. Returns: A PyArrow Table. rÝ)rŸzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type rM) rr«rÁrr¤Ú _dataframeÚ from_arrowrŸr@ÚModuleNotFoundError)ržrŸr[rrrr‚Ú_into_arrow_table¨s  r¤rcCs|S)aãVisual-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) rr rrr‚Úunstable»sr¥Úformatcst‡fdd„dDƒƒ S)a¹Determines 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. c3s|]}|ˆvVqdSr‰r)rJÚx©r¦rr‚rLár1z#_is_naive_format..)z%sz%zÚZ)Úanyr¨rr¨r‚Ú_is_naive_formatÒsr«c@sVeZdZdZd d!dd„Zd"d d „Zd#dd„Z d d$dd„Zd%dd„Ze d&dd„ƒZ dS)'Únot_implementeda¾Mark 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 NÚaliasú str | Noner‡rµcCó ||_dSr‰)Ú_alias)rŠr­rrr‚Ú__init__ r~znot_implemented.__init__rzcCs dt|ƒj›d|j›d|j›S)Nú: rM)rQr}Ú _name_ownerÚ_namerrrr‚Ú__repr__s znot_implemented.__repr__r…rSÚnamecCs|j|_|jp||_dSr‰)r}r³r°r´)rŠr…r¶rrr‚Ú __set_name__sznot_implemented.__set_name__r„ú_T | Literal['raise'] | Noneútype[_T] | NonercCs*|dur|St|d|jƒ}t|j|ƒdS)Nr¯)r‡r³Ú_raise_not_implemented_errorr´)rŠr„r…Úwhorrr‚r‹s  znot_implemented.__get__r5rcOs | d¡S)NÚraise)r‹)rŠr5rrrr‚Ú__call__$r~znot_implemented.__call__Úmessager;r=cCs|ƒ}t|ƒ|ƒS)zÛAlt constructor, wraps with `@deprecated`. Arguments: message: **Static-only** deprecation message, emitted in an IDE. [descriptor]: https://docs.python.org/3/howto/descriptor.html )r#)rèr¾rŽrrr‚r#)s znot_implemented.deprecatedr‰)r­r®r‡rµr)r…rSr¶rzr‡rµ)r„r¸r…r¹r‡r)r5rrrr‡r)r¾r;r‡r=) r}r~rr¡r±rµr·r‹r½rr#rrrr‚r¬äs $   ÿ r¬Úwhatr»ÚNotImplementedErrorcCs|›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)rÀ)r¿r»rrrr‚rº6sÿrºc@sTeZdZUdZded<ded<eddd d „ƒZeddd„ƒZddd„Z ddd„Z dS)Ú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_versionrzÚ_hintrFÚhintÚminimumr‡r=cCs| |¡}||_||_|S)z½Method decorator for raising below a minimum `_backend_version`. Arguments: minimum: Minimum backend version. hint: Optional suggested alternative. )Ú__new__rÂrÃ)rèrÅrÄrŽrrr‚rYs zrequires.backend_versionrcCsd dd„|Dƒ¡S)NrMcss|]}|›VqdSr‰r)rJÚdrrr‚rLhs€z,requires._unparse_version..)rQrrrr‚Ú_unparse_versionfrzrequires._unparse_versionr„r™rµc Csp|j|jkrdS|j}|j}| |j¡}| |j¡}d|›d|›d|›d|›d }|jr4|›d|j›}t|ƒ‚)Nú`z` is only available in 'z>=z', found version rMÚ )r§rÂÚ _wrapped_namer¯rÈrÃrÀ)rŠr„ÚmethodrýrÅÚfoundrrrr‚Ú_ensure_versionjs   zrequires._ensure_versionrú_Method[_ContextT, P, R]cs$ˆjˆ_tˆƒd ‡‡fd d „ ƒ}|S) Nr„r˜r5rrrr‡rucs ˆ |¡ˆ|g|¢Ri|¤ŽSr‰)rÎ)r„r5r©rrŠrr‚rys z"requires.__call__..wrapper)r„r˜r5rrrr‡ru)r}rËr)rŠrrrrÐr‚r½vszrequires.__call__N)rF)rÄrzrÅr¦r‡r=)rr¦r‡rz)r„r™r‡rµ)rrÏr‡rÏ) r}r~rr¡r€rrÚ staticmethodrÈrÎr½rrrr‚rÁ?s    rÁÚ str_slicergú"tuple[int | None, int | None, Any]cCsH|jdur | |j¡nd}|jdur| |j¡dnd}|j}|||fS)Nr)r¼r€r½r¾)rÒrr¼r½r¾rrr‚Úconvert_str_slice_to_int_slice‚s rÔÚ tp_parentúCallable[P, R1]ú.decorateN)rØrÙr‡rÙr)rÕr!rrÛr‚rÚ‹s  rÚúobject | type[Any]cCs@t|tƒr|nt|ƒ}|jdkr|jnd}|›d|j› d¡S)NÚbuiltinsrFrM)rÿrQr~r}Úlstrip)rŽrÚmodulerrr‚r@¦sr@r'Ú valid_typesú type[Any]r(c Gs¦t||ƒsQd dd„|Dƒ¡}d|›dt|ƒ›}|rMd}t|ƒ}t|ƒdkr.t|ƒ›d}|›|›d }d t|ƒd t|ƒ}|›d |›|›d |›}t|ƒ‚d S)aÙValidate 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 | csr/r‰)r@)rJrrrr‚rLÎr1zensure_type..z Expected z, got: z é(z(...)ú=r3ú^rÊN)rÿrQr@Úreprr8rA) rŽr(ràÚtp_namesrÚleft_padÚvalÚassignÚ underlinerrr‚r)¬s ! õr)c@s.eZdZdZddd„Zdd d „Zdd d „ZdS)Ú_DeferredIterablezLStore a callable producing an iterable to defer collection until we need it.Ú into_iterúCallable[[], Iterable[_T]]r‡rµcCr¯r‰©Ú _into_iter)rŠrìrrr‚r±Þrçz_DeferredIterable.__init__ú Iterator[_T]ccs| ¡EdHdSr‰rîrrrr‚Ú__iter__ás€z_DeferredIterable.__iter__útuple[_T, ...]cCs| ¡}t|tƒr |St|ƒSr‰)rïrÿr<)rŠÚitrrr‚Úto_tupleäsz_DeferredIterable.to_tupleN)rìrír‡rµ)r‡rð)r‡rò)r}r~rr¡r±rñrôrrrr‚rëÛs   rëé@Únestedúattrgetter[Any]cGs"|r d |g|¢R¡n|}t|ƒS)NrM)rQr)rprör¶rrr‚Údeep_attrgetterêsrøÚname_1cGst|g|¢RŽ|ƒS)z+Perform a nested attribute lookup on `obj`.)rø)rŽrùrörrr‚Ú deep_getattrðrrú)rrzr‡r9)r.r®r‡r¦)r5rr‡r6)r;rr‡r)r;r>r‡r)r3rEr‡r¦)rPrQrRrSr‡rT)rPrWrRrSr‡rX)rPrQrRrYr‡rZ)rPrWrRrYr‡r[)rPrQrRr\r‡r])rPrWrRr\r‡r^)rPrQrRr_r‡r`)rPrWrRr_r‡ra)rPrQrRrcr‡rd)rPrWrRrcr‡re)rPrQrRrfr‡rg)rPrWrRrfr‡rh)rPrQrRrjr‡rk)rPrWrRrjr‡rl)rPrrRrmr‡rn)rPrrRrr‡r)rqrrr‡rµ)r{rjr|r}r‡rj)rŽrr‡r†r‰)rŽrjr”r•r€r–r‡rj)rŽrjr‡rj)r¨rrr‡r©)rŽrrêrr‡r·)rºr»rêrr‡r)rŽrjr5rr¿rÀr‡rj)rÃrGrÄrbr‡rÅ)rØrÑr‡r)rárGrrâr‡rz)rêrrërìr§rr‡rí)rõrör‡r÷)rŽrr‡rú)rŽrr‡rþ)rŽrör‡r)rŽrr‡r)rŽrr‡r)rŽrr‡r )rŽrr‡r )rŽrrrSr‡r)rŽrrrSr‡r÷)r§rr™rrrr‡r)rrzrrr‡r)r#rGr$r%r‡r&)r+rzr,rzr‡rz)rërGrîrGr‡rH)rrGr‡rµ)rTrUrVrWr‡rX) rØrWrÃr]r_rbr`rcr‡r)rêrr‡rŽ)rêrrirâr‡rŽ)rirŽr‡rm)rŽrrprzr‡r)rŽrtr‡ru)rŽrzr‡r{)rŽrr‡r€)rŽrƒr‡r„)r1r®r‡rˆ)r1r®r‡r‹)r1r®r‡rŽ)rŽrr‡r)rŽrr‡r’)r•rGr–rGr—rzr‡r˜)ržrLrŸr±r‡r )rrsr‡rs)r¦rzr‡r)r¿rzr»rzr‡rÀ)rÒrgrrŽr‡rÓ)rÕrÖr‡r×)rŽrÜr‡rz)rŽrràrár(rzr‡rµ)rprzrörzr‡r÷)rŽrrùrzrörzr‡r)üÚ __future__rr6rHÚcollections.abcrrrrrrÚdatetimer Úenumr r Ú functoolsr r rrÚimportlib.utilrÚinspectrrÚ itertoolsrÚoperatorrÚsecretsrÚtypingrrrrrrrrrrÚnarwhals._enumr Únarwhals._exceptionsr!Únarwhals._typing_compatr"r#Únarwhals.dependenciesr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4Únarwhals.exceptionsr5r6r7r8Útypesr9rÚrCrßrDrÝÚpaÚtyping_extensionsr:r;r<r=r>r?Únarwhals._compliantr@rArBrCrDrErFÚnarwhals._compliant.typingrGrHr¾rJÚnarwhals._translaterKrLrMÚnarwhals._typingrNrOrPrQrRrËrTrUrorWrÕrYÚnarwhals.typingrZr[r\r]r^r_r`rarbrcrdrerfrgrhrzrir€rjrlrmrnrorprqrrrsrtrurvrwryrƒrr”r•r—r˜ršr›rr£r¥r©r­r±r™r´rªr®rërìrírîrïrõrðrñròrórôr)rrrr:r=r9r0rVrzrr“r¡r¦r°r¶ÚsysÚ version_infor¹r¤rÂrÐràrårärôrørýrrrr r r rrrr"r*rFrñrSrarfrhrlrorsryr}rrr‡rŠrŒrr‘r”rr¤r¥r«r¬rºrÁrÔrÚr@r)rërørúrrrr‚ÚsŒ      0 L   $    D ÿ        L õ ü       _&þü Y2     5  I '      ÿ)      R C /