o $&]i@s> UddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z ddlmZmZddlmZmZmZmZddlmZddlmZmZdd lmZdd lmZdd lm Z dd l!m"Z"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/m0Z0ddl1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJmKZKe"rddlmLZLddlMmNZNddlOZPddlQZRddlSZTddlUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]m^Z^m_Z_ddl`maZaddlbmcZcmdZdmeZemfZfddlgmhZhddlimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZuddlvmwZwmxZxmyZyddlzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZeZd ed!<e)d"e*ee#ee#ee#fd#Ze)d$Ze)d%Ze)d&Ze)d'd(d#ZeXd)Ze)d*Ze)d+Ze)d,ZGd-d.d.e(ZGd/d0d0e(ZGd1d2d2e(Ze)d3Ze)d4d5d6Ze)d7d5d6Zd8Zd ed9<e)d:ed#Zd;Zd ed<<d=Zd ed><Gd?d@d@e(eZGdAdBdBe(eZGdCdDdDe(ZGdEdFdFe(ZGdGdHdHe(ZGdIdJdJeee(ZGdKdLdLeee(ZGdMdNdNee(ZGdOdPdPeZGdQdRdRe.ZejdSejdTejdUejdVejdWejdWejdXejdYejdZejd[ejd\i Zd]ed^<ejd_ejd`ejdaejdbiZdcedd< ededfddkdlZeddodpZӐddtduZԐddwdxZՐdd{d|Z֐dddZאdddZe,dddZe,dddZe,dddZe,dddZe,dddZe,dddZe,dddZِdddZِdddZڐdddZېdddZ ddddddZݐdddZe"r;eed5dZnddlZejdkrLeed5dZndddZdddZdddÄZdddDŽZddd΄Zddd҄Z ӐdԐdddلZ ӐdԐdddۄZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdddZdd d ZdddZddddddZdddZdd d!Zdd%d&Zdd'd(Zdd.d/Zdd8d9Zdd;d<Zdd>d?ZddAdBZeZdCedD<ddFdGZddJdKZddNdOZddRdSZddTdUZddVdWZddYdZZ dd]d^Z dd`daZ ddcddZ ddfdgZ ddidjZddodpZddudvZddxdyZdd{d|ZGd}d~d~ZdddZGdddZdddZdddZdddZdddddZGddde&eZeddfdddZdddZGdddeeee(eZGddde(eZGdddZdddZ dddZ!dddZ"GdddeZ#e#j$Z$e%dZ&dS() annotationsN) Collection ContainerIterableIteratorMappingSequence)timezone)Enumauto)cache lru_cachepartialwraps) find_spec)getattr_staticgetdoc)chain) attrgetter) token_hex) TYPE_CHECKINGAnyCallableFinalGenericLiteralProtocolTypeVarUnioncastoverload) 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_boolis_narwhals_series_intis_numpy_array_1dis_numpy_array_1d_boolis_numpy_array_1d_intis_pandas_like_dataframeis_pandas_like_series)ColumnNotFoundErrorDuplicateErrorInvalidOperationError)Set) ModuleType) Concatenate LiteralString ParamSpecSelf TypeAliasTypeIs)CompliantExprTCompliantSeriesTNativeSeriesT_co)NamespaceAccessor)Accessor EvalNamesNativeDataFrameTNativeLazyFrameT Namespace) NativeArrow NativeCuDF NativeDask NativeDuckDB NativeIbis NativeModin NativePandasNativePandasLike NativePolars NativePySparkNativePySparkConnectNativeSQLFrame)ArrowStreamExportableIntoArrowTableToNarwhalsT_co)Backend IntoBackend _ArrowImpl _CuDFImpl _DaskImpl _DuckDBImpl_EagerAllowedImpl _IbisImpl_LazyAllowedImpl_LazyFrameCollectImpl _ModinImpl _PandasImpl_PandasLikeImpl _PolarsImpl_PySparkConnectImpl _PySparkImpl _SQLFrameImpl DataFrame LazyFrameDTypeSeries)CompliantDataFrameCompliantLazyFrameCompliantSeriesDTypes FileSource IntoSeriesTMultiIndexSelectorSingleIndexSelectorSizedMultiBoolSelectorSizedMultiIndexSelectorSizeUnitSupportsNativeNamespaceTimeUnit_1DArray _SliceIndex _SliceName _SliceNonerAUnknownBackendNameFrameOrSeriesT)bound_T1_T2_T3_FnzCallable[..., Any]PRR1R2c@eZdZUded<dS)_SupportsVersionstr __version__N__name__ __module__ __qualname____annotations__rrM/var/www/html/IGF-ODF-V3/venv/lib/python3.10/site-packages/narwhals/_utils.pyrs rc@seZdZd d ddZdS) _SupportsGetNinstancerowner Any | NonereturncCdSNrselfrrrrr__get__sz_SupportsGet.__get__r)rrrrrr)rrrrrrrrrsrc@eZdZedddZdS)_StoresColumnsr Sequence[str]cCrrrrrrrcolumnsz_StoresColumns.columnsN)rr)rrrpropertyrrrrrrr_T NativeT_coT) covariant CompliantT_coz._FullContext | NamespaceAccessor[_FullContext] _IntoContext _IntoContextTz*Callable[Concatenate[_IntoContextT, P], R]_Methodz Callable[Concatenate[_T, P], R2] _Constructorc@eZdZdZedddZdS) _StoresNativezProvides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table rrcCdS)zReturn the native object.Nrrrrrnativez_StoresNative.nativeN)rr)rrr__doc__rrrrrrrrc@r)_StoresCompliantzProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame rrcCr)zReturn the compliant object.Nrrrrr compliantrz_StoresCompliant.compliantN)rr)rrrrrrrrrrrrrc@r)_StoresBackendVersionrtuple[int, ...]cCr)z#Version tuple for a native package.Nrrrrr_backend_versionrz&_StoresBackendVersion._backend_versionNrr)rrrrrrrrrrrrc@r)_StoresVersionVersion_versionNrrrrrr rc@r)_StoresImplementationImplementation_implementationNrrrrrrrrc@eZdZdZdS)_LimitedContextzEProvides 2 attributes. - `_implementation` - `_version` Nrrrrrrrrrrc@r) _FullContextzMProvides 2 attributes. - `_implementation` - `_backend_version` Nrrrrrrrrc@eZdZdZdddZdS)ValidateBackendVersionz=Ensure the target `Implementation` is on a supported version.rNonecCs|j}dS)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_rrr_validate_backend_versionsz0ValidateBackendVersion._validate_backend_versionN)rr)rrrrrrrrrrsrc@sdeZdZeZeZeZedddZedddZ edd d Z edd d Z edddZ dS)rrtype[Namespace[Any]]cCD|tjur ddlm}|S|tjurddlm}|Sddlm}|S)NrrK)rV1narwhals.stable.v1._namespacerLV2narwhals.stable.v2._namespacenarwhals._namespace)r NamespaceV1 NamespaceV2rLrrr namespace     zVersion.namespacerwcCr)Nr)dtypes)rrnarwhals.stable.v1rrnarwhals.stable.v2narwhals)r dtypes_v1 dtypes_v2rrrrr rzVersion.dtypestype[DataFrame[Any]]cCr)Nrrn)rrrrnrrnarwhals.dataframe)r DataFrameV1 DataFrameV2rnrrr dataframerzVersion.dataframetype[LazyFrame[Any]]cCr)Nrro)rrrrorrr)r LazyFrameV1 LazyFrameV2rorrr lazyframe&rzVersion.lazyframetype[Series[Any]]cCr)Nrrr)rrrrsrrnarwhals.series)rSeriesV1SeriesV2rsrrrseries4rzVersion.seriesN)rr)rrw)rr)rr)rr) rrrr rrMAINrrrrrrrrrrrs     rc@s"eZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z d@ddZedAddZedBddZedCddZdDdd ZdEd"d#ZdEd$d%ZdEd&d'ZdEd(d)ZdEd*d+ZdEd,d-ZdEd.d/ZdEd0d1ZdEd2d3ZdEd4d5ZdEd6d7Z dEd8d9Z!dEd:d;Z"dFd=d>Z#d?S)Grz?Implementation of native object (pandas, Polars, PyArrow, ...).pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframezpyspark[connect]unknownrrcCs t|jSr)rvaluerrrr__str___ zImplementation.__str__cls type[Self]native_namespacer<cCsjttjttjttjttjt tj t tj t tjttjttjttjttji }||tjS)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)rrmappingrrrfrom_native_namespacebs  z$Implementation.from_native_namespace backend_namecCs$z||WStytjYSw)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. ) ValueErrorrr)rrrrr from_stringzs    zImplementation.from_stringbackend)IntoBackend[Backend] | UnknownBackendNamecCs,t|tr ||St|tr|S||S)zInstantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. ) isinstancerrrr)rrrrr from_backends 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)rrAssertionErrorr_IMPLEMENTATION_TO_MODULE_NAMErr_import_native_namespace)rmsg module_namerrrto_native_namespaces z"Implementation.to_native_namespaceboolcC |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 )rrrrrr 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 )rrrrrrrris_pandas_likes 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 )rr rrrrrr is_spark_likes  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 )rr rrrr is_polarsr%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 )rrrrrris_cudfr%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 )rrrrrris_modinr%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 )rr rrrr is_pysparkr%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 )rrrrrris_pyspark_connectr%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 )rr 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 )rr rrrris_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 )rr 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 )rrrrrris_ibis4r%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 )rrrrrr is_sqlframeAr%zImplementation.is_sqlframercCst|S)zReturns backend version.backend_versionrrrrrNszImplementation._backend_versionNrr)rrrr<rr)rrrrrr)rrrrrr)rr<)rr"r)$rrrrrrrr r r r r rrrrr classmethodrrrr!r$r'r(r)r*r+r,r-r.r/r0r1r2rrrrrrCs`        r)r7)r) ) )r8)r)ir9)r7r7))r8rz(Mapping[Implementation, tuple[int, ...]] MIN_VERSIONSzdask.dataframez modin.pandasz pyspark.sqlzpyspark.sql.connectzMapping[Implementation, str]r)maxsizer rrr<cCsddlm}||S)Nr) import_module) importlibrF)r rFrrrrjs rimplementationrc Cst|ts t||tjurdS|}t||j}t|}|r)ddl }|j }n| s1| r8ddl }|}n |rCddl}|}n|}t|}|t|} kr`d|d| d|} t| |S)N)rrrrzMinimum version of z supported by Narwhals is z , found: )rrr#rrrrrr2sqlframe._versionrr,r-rr/r parse_versionrCr) rHimplr rr into_versionrrversion min_versionrrrrr4ts,  r4argsr list[Any]cCs*tt|dkrt|dr|dS|S)Nr7r)listlen _is_iterable)rOrrrflattens*rTargcCst|ttfs |fS|Sr)rrQtuple)rUrrrtupleifysrWAny | Iterable[Any]r"cCsddlm}t}durt||j|jfs*t}dur6t||j|j|j|jfr6dt|d}t |t|t oCt|t t |f S)Nrrrz(Expected Narwhals class or scalar, got: z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?) rrsr*rrnr+Exprroqualified_type_name TypeErrorrrbytes)rUrspdplrrrrrSs  rSvalIterable[_T] | AnyTypeIs[Iterator[_T]]cC t|tSr)rr)r_rrr is_iteratorrrcrM#str | ModuleType | _SupportsVersioncCs:t|tr|n|j}tdd|}tdd|dDS)zSimple version parser; split into a tuple of ints for comparison. Arguments: version: Version string, or object with one, to parse. z (\D?dev.*$)css"|] }ttdd|VqdS)z\DreN)intresub).0vrrr s z parse_version...)rrrrgrhrVsplit)rM version_strrrrrJs rJ obj_or_clstype cls_or_tupletype[_T]TypeIs[type[_T]]cCrrrrorqrrrisinstance_or_issubclassrru object | typeTypeIs[_T | type[_T]]cCrrrrtrrrrurtuple[type[_T1], type[_T2]]TypeIs[type[_T1 | _T2]]cCrrrrtrrrrur#TypeIs[_T1 | _T2 | type[_T1 | _T2]]cCrrrrtrrrrur&tuple[type[_T1], type[_T2], type[_T3]]TypeIs[type[_T1 | _T2 | _T3]]cCrrrrtrrrrur/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]]cCrrrrtrrrrurtuple[type, ...] TypeIs[Any]cCrrrrtrrrrurcCs>ddlm}t||rt||St||pt|tot||S)Nrrp)narwhals.dtypesrqrrp issubclass)rorqrqrrrrus    items Iterable[Any]rcs\ddlmmtfdd|Dstfdd|Dr dSddd|D}t|) Nrrmc3|]}t|VqdSrrriitemrrrrkz$validate_laziness..c3rrrrrrrrkrzGThe items to concatenate should either all be eager, or all lazy, got: cSsg|]}t|qSr)rprrrr sz%validate_laziness..)rrnroallr[)rrrrmrvalidate_lazinesssrlhsrhs-Series[Any] | DataFrame[Any] | LazyFrame[Any]cCsddlm}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 |rtt|d d |r||j jj ||jjj | |j |j jj |jjj Stt|d d |rtt|d d |r||j jj ||j jj | |j |j jj |j jj St|t|krd t|dt|}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. 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)PandasLikeSeriesindexrrrcSs|js d}t|dS)Nz'given index doesn't have a unique index) is_uniquer)rrrrr_validate_index$sz*maybe_align_index.._validate_index_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrrr)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrrrgetattrrrr_with_compliant _with_nativelocrrRr)rrrrrlhs_anyrhs_anyrrrrmaybe_align_indexs~         robj-DataFrame[Any] | LazyFrame[Any] | Series[Any]rcCs,td|}|}t|st|r|jSdS)aGet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or 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 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_nativer6r7r)robj_any native_objrrrmaybe_get_index_s r)r column_namesstr | list[str] | Noner6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonecsddlmtd|}|}|dur|durd}t||s)|dur)d}t||durAt|r:fdd|Dn|d d }n|}t|rS||j| |St |rwdd l m }|red }t|||||j j d }||j |S|S)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. 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 rrrNz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedcsg|]}|ddqS)T pass_throughr)riidxrrrrz#maybe_set_index..Tr) set_indexz/Cannot set index using column names on a Series)rH)narwhals.translaterrrrSr6rrrrr7narwhals._pandas_like.utilsrr)rrrdf_anyrrkeysrrrrmaybe_set_indexs> ,    rcCstd|}|}t|r%|}t||r|S||j|jddSt |rA|}t||r4|S||j |jddS|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. 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) rrr6__native_namespace___has_default_indexrrr reset_indexr7r)rrrrrrrmaybe_reset_indexs"   r)strict)r8r< iterablesIterable[tuple[Any, ...]]cstt|dkr t|Sdd fdd }d fdd }t|}tt||}ttt|tt|gR|S) Nr:Frrc3s ddS)NTrr) first_stoppedrr first_tailszzip_strict..first_tailc3s0s d}t|tD]}d}t|dS)Nz$zip_strict: first iterable is longerz%zip_strict: first iterable is shorter)rr from_iterable)rrrrestrrzip_tailszzip_strict..zip_tail)rr)rRzipiterrnextrQmap)rrr iterables_itfirstrrr zip_stricts  rrTypeIs[pd.RangeIndex]cCs t||jSr)r RangeIndex)rrrrr_is_range_index-s rnative_frame_or_seriespd.Series[Any] | pd.DataFramecCs2|j}t||o|jdko|jt|ko|jdkS)Nrr7)rrstartstoprRstep)rrrrrrr1s  rkwargs bool | strcOs:|js|S||j|j|i|}td|S)a-Convert 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. 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)rHr'r _compliantrrconvert_dtypesr)rrOrresultrrrmaybe_convert_dtypes=s ! rszrfunitr~ int | floatcCs^|dvr|S|dvr|dS|dvr|dS|dvr|dS|dvr&|d 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 >br\>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got r)rrrrrr scale_bytesfs rr Series[Any]cCsddlm}|jjj}|j}d}t||r$t|j|jr$|jj d}|S|j|j kr.d}|S|j|jkr8d}|S| }|j }| rT|dkrTtd|jjdk}|S|r`t|jj}|S|rsdd lm}||jor|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. Examples: >>> import narwhals as nw >>> import pandas as pd >>> import polars as pl >>> data = ["x", "y"] >>> >>> s_pd = nw.from_native( ... pd.Series(data, dtype=pd.CategoricalDtype(ordered=True)), series_only=True ... ) >>> nw.is_ordered_categorical(s_pd) True >>> s_pl = nw.from_native( ... pl.Series(data, dtype=pl.Categorical()), series_only=True ... ) >>> nw.is_ordered_categorical(s_pl) False r)InterchangeSeriesF is_orderedT)r7 zpl.Categoricalphysical) is_dictionary)narwhals._interchange.seriesrrrrrdtype Categoricalrdescribe_categoricalr rrHr)rrorderingr'r"catorderedr.narwhals._arrow.utilsrrp)rrrrrrrKrrrris_ordered_categorical{s6 #       rnwn_bytesrContainer[str]prefixcCsd}t|ddt|||dS)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versionsz1.13.0r)rrr)r"generate_temporary_column_name)rrrrrrrgenerate_unique_tokens rcCsPd} |t|d}||vr|S|d7}|dkr'd|d|}t|q)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. prefix: prefix with which the temporary column name should start with. 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 >>> temp_name = nw.generate_temporary_column_name( ... n_bytes=8, columns=columns, prefix="foo" ... ) >>> temp_name not in columns and temp_name.startswith("foo") True rTr7dzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr)rrrcountertokenrrrrrsrframesubset Iterable[str]r list[str]cCs:|s tt|j|St|}t||jd}r||S)N) available)rQsetr intersectioncheck_columns_exist)rrrto_droperrorrrrparse_columns_to_drops rsequenceSequence[_T] | AnyTypeIs[Sequence[_T]]cCst|to t|t Sr)rrr)rrrris_sequence_but_not_strr TypeIs[_SliceNone]cCst|to |tdkSr)rslicerrrr is_slice_noner rCTypeIs[SizedMultiIndexSelector[Series[Any] | CompliantSeries[Any]]]cCsDt|ot|dkrt|dpt|dkp!t|p!t|p!t|SNr)r rRis_single_index_selectorr5r2is_compliant_series_intrrrris_sized_multi_index_selectors"r-TypeIs[Sequence[_T] | Series[Any] | _1DArray]cCs t|pt|pt|pt|Sr)r r3r0is_compliant_seriesrrrris_sequence_likesrTypeIs[_SliceIndex]cCsFt|to"t|jtp"t|jtp"t|jttfo"|jduo"|jduSr)rrrrfrrNoneTyperrrris_slice_index!s   r TypeIs[range]cCrbr)rrangerrrris_range-rrTypeIs[SingleIndexSelector]cCstt|to t|t Sr)r"rrfrrrrr1srTTypeIs[SingleIndexSelector | MultiIndexSelector[Series[Any] | CompliantSeries[Any]]]cCst|p t|p t|Sr)rrrrrrris_index_selector5s r!BTypeIs[SizedMultiBoolSelector[Series[Any] | CompliantSeries[Any]]]cCs:t|rt|dkrt|dtpt|pt|pt|Sr)r rRrr"r4r1is_compliant_series_boolrrrris_boolean_selector?s"r$tpTypeIs[list[_T]]cCs tt|to|ot|d|Sr)r"rrQ)rr%rrr is_list_ofJs r' predicatesCollection[Any]TypeIs[Collection[list[bool]]]cCstdd|DS)Ncss|]}t|tVqdSr)r'r")ripredrrrrkRrz3predicates_contains_list_of_bool..any)r(rrr predicates_contains_list_of_boolOr.cCs(tt|ott|d}ot||Sr)r"r rrr)rr%rrrris_sequence_ofUs r0 bool | Nonerpass_through_defaultcCsT|dur |dur |}|S|dur|dur| }|S|dur$|dur$ |Sd}t|)Nz,Cannot pass both `strict` and `pass_through`r)rrr2rrrrvalidate_strict_and_pass_though^sr3reF) warn_versionrequiredr4r5*Callable[[Callable[P, R]], Callable[P, R]]csdfdd }|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**. fnCallable[P, R]rcstd fdd }|S) NrOP.argskwdsP.kwargsrrcs|dd}|dd}|dur!|dur!rd}t|d|}n#|dur/|dur/d}t||durD|durDrDdjd}t|||d<|i|S)Nrrz`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)rOr:rrr)r7r5r4rrwrapper~s   z=deprecate_native_namespace..decorate..wrapper)rOr9r:r;rr)r)r7r=r5r4r7rdecorate}sz,deprecate_native_namespace..decorateN)r7r8rr8r)r4r5r@rr>rdeprecate_native_namespaceps rA window_size min_samples int | Nonetuple[int, int]cCszt|tddt|ttddd|dkrd}t||dur7|dkr)d}t|||kr3d}t|||fS|}||fS)NrB param_namerCr7z+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_typerfrprr:)rBrCrrrr_validate_rolling_argumentssrIheader native_reprc Csztj}Wntyttdd}Ynw|}tdd|D}|d|krt|t |}dd|d}|t |}|d d |d|d |d|dd 7}|d d |d 7}||d}||d||d} |D]} |d d || d | |t | d 7}qy|d d|d7}|Sdt |} dddd | d|d | d| dddd S)NCOLUMNSPcs|]}t|VqdSr)rR)rilinerrrrkz generate_repr..r:u┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorrfgetenv expandtabs splitlinesmaxrR) rJrKterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrarOdiffrrr generate_reprs<    0 .  reCollection[str]rColumnNotFoundError | NonecCs"t||}rt||SdSr)r differencer8'from_missing_and_available_column_names)rrmissingrrrrs rcCsht|tt|kr2ddlm}||}dd|D}ddd|D}d|}t|dS) Nr)CountercSsi|] \}}|dkr||qS)r7rrikrjrrr sz1check_column_names_are_unique..recss&|]\}}d|d|dVqdS)z - 'z' z timesNrrlrrrrks$z0check_column_names_are_unique..z"Expected unique column names, got:)rRr collectionsrkrjoinr9)rrkr duplicatesrrrrcheck_column_names_are_uniques  rr time_unit$TimeUnit | Iterable[TimeUnit] | None time_zone7str | timezone | Iterable[str | timezone | None] | None%tuple[Set[TimeUnit], Set[str | None]]cCsd|durhdn t|tr|hnt|}|durdhnt|ttfr't|hndd|D}||fS)N>smsnsuscSs h|] }|dur t|ndqSr)r)ritzrrr s z1_parse_time_unit_and_time_zone..)rrrr )rsru time_units time_zonesrrr_parse_time_unit_and_time_zones   rrrqrrwr~ Set[TimeUnit]rSet[str | None]cCs2t||jo|j|vo|j|vpd|vo|jduS)N*)rDatetimersru)rrr~rrrr%dtype_matches_time_unit_and_time_zones  rrcCs|jSrr)rrrrget_column_namessrnamescsfdd|jDS)Ncsg|]}|vr|qSrr)ricol_namerrrr rz(exclude_column_names..r)rrrrrexclude_column_names rEvalNames[Any]csdfdd }|S)N_framerrrcsSrr)rrrrr7rz$passthrough_column_names..fn)rrrrr)rr7rrrpassthrough_column_namessrr _SENTINELattrcCst||ttuSr)rr)rrrrr_hasattr_staticsr\CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co] | Any^TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co]]cC t|dS)N__narwhals_dataframe__rrrrris_compliant_dataframes rJCompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co] | AnyLTypeIs[CompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co]]cCr)N__narwhals_lazyframe__rrrrris_compliant_lazyframe' r'CompliantSeries[NativeSeriesT_co] | Any)TypeIs[CompliantSeries[NativeSeriesT_co]]cCr)N__narwhals_series__rrrrrr-rrcCt|o|jSr)rr is_integerrrrrr3r/rcCrr)rr is_booleanrrrrr#9r/r#'TypeIs[NamespaceAccessor[_FullContext]]cCst|do t|dS)Nr _accessorrrrrr_is_namespace_accessor?srrKTypeIs[_EagerAllowedImpl]cCs|tjtjtjtjtjhvS)z.Return True if `impl` allows eager operations.)rrrrr r rKrrris_eager_allowedIsrTypeIs[_LazyFrameCollectImpl]cCr&)z4Return True if `LazyFrame.collect(impl)` is allowed.)rrr r rrrrcan_lazyframe_collectTrTypeIs[_LazyAllowedImpl]cCs$|tjtjtjtjtjtjtjhvS)z1Return True if `DataFrame.lazy(impl)` is allowed.)rr r rr r rrrrrris_lazy_allowedYsrTypeIs[SupportsNativeNamespace]cCr)Nrrrrrrhas_native_namespacefrrTypeIs[ArrowStreamExportable]cCr)N__arrow_c_stream__rrrrrsupports_arrow_c_streamjrrleft_onright_onsuffixdict[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|VqdSrr)rikeyrrrrrk~s z(_remap_full_join_keys..)dictr)rrrright_keys_suffixedrrr_remap_full_join_keysns rdatarZcontextpa.TablecCsBtdr|jjdj}|jj||djSdt|d}t |)zGuards `ArrowDataFrame.from_arrow` w/ safer imports. Arguments: data: Object which implements `__arrow_c_stream__`. context: Initialized compliant object. r)rzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type rl) rrrrr _dataframe from_arrowrrZModuleNotFoundError)rrrzrrrr_into_arrow_tables rr7cCs|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) rr?rrrunstablesrformatcstfdddD 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. c3s|]}|vVqdSrr)rixrrrrkrPz#_is_naive_format..)z%sz%zZr,rrrr_is_naive_formatsrc@sVeZdZdZd d!ddZd"d d Zd#ddZ d d$ddZd%ddZe d&ddZ dS)'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 Nalias str | NonerrcC ||_dSr)_alias)rrrrr__init__rznot_implemented.__init__rcCs dt|jd|jd|jS)N: rl)rpr _name_owner_namerrrr__repr__s znot_implemented.__repr__rrrnamecCs|j|_|jp||_dSr)rrrrrrrrrr __set_name__sznot_implemented.__set_name__r_T | Literal['raise'] | Nonetype[_T] | NonercCsD|dur|St|dtj}|tjurt|}n|j}t|j|dS)Nr)rrrreprr_raise_not_implemented_errorr)rrrrHwhorrrrs   znot_implemented.__get__rOr:cOs |dS)Nraise)r)rrOr:rrr__call__rznot_implemented.__call__messager>r@cCs|}t||S)zAlt constructor, wraps with `@deprecated`. Arguments: message: **Static-only** deprecation message, emitted in an IDE. [descriptor]: https://docs.python.org/3/howto/descriptor.html )r$)rrrrrrr$s znot_implemented.deprecatedr)rrrrr5)rrrrrrr)rrrrrr)rOrr:rrr)rr>rr@) rrrrrrrrrr6r$rrrrrs $   rwhatrNotImplementedErrorcCs|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)rrrrrrrsrc@sreZdZUdZded<ded<ded< ed"d#d d Zed$ddZd%ddZ d&ddZ d'ddZ d(dd Z d!S))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_hint _wrapped_namerehintminimumrr@cCs||}||_||_|S)zMethod decorator for raising below a minimum `_backend_version`. Arguments: minimum: Minimum backend version. hint: Optional suggested alternative. )__new__rr)rrrrrrrr4;s zrequires.backend_versionr4cCsddd|DS)Nrlcss|]}|VqdSrr)ridrrrrkJsz,requires._unparse_version..)rpr3rrr_unparse_versionHrzrequires._unparse_versionrrGrcCs$d|jvr|d|j|_dSdSNrl)r)rrrrr_qualify_accessor_nameLs zrequires._qualify_accessor_namerrtuple[tuple[int, ...], str]cCs0t|r||j|j}n|}|jt|jfSr)rrrrrrr)rrrrrr_unwrap_contextQs  zrequires._unwrap_contextc Csp||\}}||jkrdS||j}||}d|jd|d|d|d }|jr4|d|j}t|)N`z` is only available in 'z>=z', found version rl )rrrrrr)rrrMrrfoundrrrr_ensure_versionYs    zrequires._ensure_versionr7_Method[_IntoContextT, P, R]cs$j_td fd d }|S) NrrrOr9r:r;rrcs ||g|Ri|Sr)r)rrOr:r7rrrr=is z"requires.__call__..wrapper)rrrOr9r:r;rr)rrr)rr7r=rrrrdszrequires.__call__N)re)rrrrrr@)r4rrr)rrGrr)rrrr)rrrr)r7rrr) rrrrrr6r4 staticmethodrrrrrrrrrrs      r str_slicer"tuple[int | None, int | None, Any]cCsH|jdur ||jnd}|jdur||jdnd}|j}|||fS)Nr7)rrrr)rrrrrrrrconvert_str_slice_to_int_slicers r tp_parentCallable[P, R1].decorateN)rrrrr)rr@rrrr{s  robject | type[Any]cCs@t|tr|nt|}|jdkr|jnd}|d|jdS)Nbuiltinsrerl)rrprrlstrip)rr%modulerrrrZsrZrF valid_types type[Any]rGc Gst||sQddd|D}d|dt|}|rMd}t|}t|dkr.t|d}||d }d t|d t|}|d ||d |}t|d S)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 | csrNr)rZ)rir%rrrrkrPzensure_type..z Expected z, got: z (z(...)=rR^rN)rrprZrrRr[) rrGrtp_namesrleft_padr_assign underlinerrrrHs ! rHc@s.eZdZdZdddZdd d Zdd d ZdS)_DeferredIterablezLStore a callable producing an iterable to defer collection until we need it. into_iterCallable[[], Iterable[_T]]rrcCrr _into_iter)rr rrrrrz_DeferredIterable.__init__ Iterator[_T]ccs|EdHdSrrrrrr__iter__sz_DeferredIterable.__iter__tuple[_T, ...]cCs|}t|tr |St|Sr)rrrV)ritrrrto_tuplesz_DeferredIterable.to_tupleN)r rrr)rr)rr)rrrrrrrrrrrr s   r @nestedattrgetter[Any]cGs"|r d|g|Rn|}t|Sr)rpr)rrrrrrdeep_attrgettersrname_1cGst|g|R|S)z+Perform a nested attribute lookup on `obj`.)r)rrrrrr deep_getattrrrc@s eZdZdS) CompliantN)rrrrrrrrsrc@r)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 rCompliant[NativeT_co]cCrrrrrrrrrzNarwhals._compliantN)rr)rrrrrrrrrrrsrc@seZdZdZd=dd Zed>ddZed?ddZed@ddZedAddZedBddZedCddZedDd!dZedEd$dZedFd'dZedGd*dZedHd-dZedId0dZedJd3dZedKd6dZedLd9dZdMd;dZdrrr extend_boolMsr@c@r) _NoDefault NO_DEFAULTrrcCr)Nz rrrrrr]rz_NoDefault.__repr__Nr5)rrr no_defaultrrrrrrAXsrA)r rrr<)rHrrr)rOrrrP)rUrrr)rUrXrr")r_r`rra)rMrdrr)rorprqrrrrs)rorvrqrrrrw)rorprqrxrry)rorvrqrxrrz)rorprqr{rr|)rorvrqr{rr})rorrqr~rr)rorrqrrr")rrrr)rrrrrr)rrrrr)rrrrrrrr)rrrr)rrrr)rrrrrr)rrrrrr")rrrOr"rrrr)rrfrr~rr)rrrr")r)rrfrrrrrr)rrrrrr"rr)rr rr )rrrr )rrrr)rr rr)rrrr)rrrr)rrrr)rrrr )rrrr")rrr%rrrr&)r(r)rr*)rrr%rrrr )rr1rr1r2r"rr")r4rr5r"rr6)rBrfrCrDrrE)rJrrKrrr)rrfrrfrrg)rrfrr)rsrtrurvrrw) rrqrrwr~rrrrr")rrrr)rrrrrr)rrrr)rrrrrr")rrrr)rrrr)rrrr)rrrr)rKrrr)rKrrr)rKrrr)rrrr)rrrr)rrfrrfrrrr)rrZrrrr)r7rrr)rrrr")rrrrrr)rrrrrr)rrrr)rrrr)rrrrrGrrr)rrrrrr)rrrrrrrr)r2r3rr)r9rxrr)rr=r>rfrr?(' __future__rrUrgsyscollections.abcrrrrrrdatetimer enumr r functoolsr r rrimportlib.utilrinspectrr itertoolsroperatorrsecretsrtypingrrrrrrrrrrr narwhals._enumr!narwhals._exceptionsr"narwhals._typing_compatr#r$narwhals.dependenciesr%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7narwhals.exceptionsr8r9r:r;typesr<rr]rr^rr7typing_extensionsr=r>r?r@rArBnarwhals._compliantrCrDrE!narwhals._compliant.any_namespacerFnarwhals._compliant.typingrGrHrIrJrrLnarwhals._nativerMrNrOrPrQrRrSrTrUrVrWrXnarwhals._translaterYrZr[narwhals._typingr\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrrnrorrqrrsnarwhals.typingrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rr r r rrrCrrr4rTrWrSrcrJrurrrrrrr version_inforrrrrrrrr rrrrrrr!r$r'r.r0r3rArIrerrrrrrrrobjectrrrrrrr#rrrrrrrrrrrrrrrrZrHr rrrrrr8r<r@rArCrprrrrrs      4  T     8L  L         L          \# V/     ) C  -        )       V V / 6