-Ph UddlmZddlZddlZddlmZddlmZmZddl m Z ddl m Z ddl mZmZddlmZdd lmZmZmZmZmZmZmZmZmZmZmZmZmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@mAZAmBZBerddlCmDZDddlmEZFddlGZHddlIZJddlKZLddlMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]ddl^m_Z_m`Z`ddlambZbmcZcmdZdddlemfZfmgZgddlhmiZiddljmkZkddllmmZmmnZnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|edeegeefeekefZ}edZ~edZedZedd ZePd!Zed"Zed#Zed$ZGd%d&eZGd'd(eZGd)d*eZGd+d,eZGd-d.eZGd/d0eeeZGd1d2eeeZGd3d4eZed5Zed6d78Zed9d78Zed:d2Zd;ZdZddvZe d?dxZe d@d{Ze dAd}Ze dBdZdCdZdDdZdEdZdFdZ dGdddHdZdIdZdJdZdKdZdLdZdMdZdNdZdOdZdOdZdPdZdQdZdRdZdSdZdTdZdUdZdVdZdWdZdXd„ZdYdńZdZdƄZÐd[dDŽZĐd\dʄZŐd]dτZdddҜd^dքZǐd_dۄZȐd`dބZɐdadZʐdbdZːdcdZ̐dddZ͐dedZΐdfdZϐdgdZАdhdZѐdidZҐdjdZӐdkdZԐdkdZՐdldZ֐dmdZאdnd Zؐdod ZِdpdZڐdqdZېdrdZܐdsdZݐdtdZGddZߐdud!ZGd"d#Zdvd'Zdwd+Zdxd-ZdАd.dyd2ZGd3d4eeZdS(z) annotationsN)timezone)Enumautowraps) find_spec)getattr_staticgetdoc) token_hex) TYPE_CHECKINGAnyCallable ContainerGenericIterableIteratorLiteralProtocolSequenceTypeVarUnioncastoverload)warn) NoAutoEnum deprecated)get_cudfget_daskget_dask_dataframe get_duckdbget_ibis get_modin get_pandas get_polars get_pyarrow get_pysparkget_pyspark_connectget_pyspark_sql get_sqlframeis_narwhals_seriesis_narwhals_series_intis_numpy_array_1dis_numpy_array_1d_intis_pandas_dataframeis_pandas_like_dataframeis_pandas_like_seriesis_pandas_seriesis_polars_seriesis_pyarrow_chunked_array)ColumnNotFoundErrorDuplicateErrorInvalidOperationError) ModuleType) AbstractSet) Concatenate LiteralString ParamSpecSelf TypeAliasTypeIs) CompliantExprCompliantExprTCompliantFrameTCompliantSeriesOrNativeExprT_coCompliantSeriesTNativeFrameT_coNativeSeriesT_co) EvalNames)EagerAllowedImplementation Namespace)ArrowStreamExportableIntoArrowTableToNarwhalsT_co DataFrame LazyFrameDTypeSeries)CompliantDataFrameCompliantLazyFrameCompliantSeries DataFrameLikeDTypes IntoSeriesTMultiIndexSelectorSingleIndexSelectorSizedMultiIndexSelectorSizeUnitSupportsNativeNamespaceTimeUnit_1DArray _SliceIndex _SliceName _SliceNoneFrameOrSeriesT)bound_T1_T2_T3_FnzCallable[..., Any]PRR1R2ceZdZUded<dS)_SupportsVersionstr __version__N__name__ __module__ __qualname____annotations__O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/narwhals/_utils.pyrprpysryrpceZdZdd dZdS) _SupportsGetNinstancerowner Any | NonereturncdSNrx)selfr}r~s rz__get__z_SupportsGet.__get__}sryr)r}rr~rrr)rtrurvrrxryrzr|r||sQQQQQQQryr|ceZdZUded<dS)_StoresImplementationImplementation_implementationNrsrxryrzrrs''''MMryrceZdZUded<dS)_StoresBackendVersiontuple[int, ...]_backend_versionNrsrxryrzrrs))))11ryrceZdZUded<dS)_StoresVersionVersion_versionNrsrxryrzrrs00ryrceZdZdZdS)_LimitedContextzRProvides 2 attributes. - `_backend_version` - `_version` Nrtrurv__doc__rxryrzrrs    ryrceZdZdZdS) _FullContextznProvides 3 attributes. - `_implementation` - `_backend_version` - `_version` Nrrxryrzrrs    ryrc&eZdZeddZdS)_StoresColumnsr Sequence[str]cdSrrxrs rzcolumnsz_StoresColumns.columnss,/CryN)rr)rtrurvpropertyrrxryrzrrs& /// ///ryr_T NativeT_coT) covariant CompliantT_co _ContextTz&Callable[Concatenate[_ContextT, P], R]r?_Methodz Callable[Concatenate[_T, P], R2] _Constructorc*eZdZdZeddZdS) _StoresNativezProvides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table rrcdS)zReturn the native object.Nrxrs rznativez_StoresNative.native  ryN)rr)rtrurvrrrrxryrzrr>   X   ryrc*eZdZdZeddZdS)_StoresCompliantzProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame rrcdS)zReturn the compliant object.Nrxrs rz compliantz_StoresCompliant.compliantrryN)rr)rtrurvrrrrxryrzrrrryrceZdZeZeZed dZeddZeddZ edd Z edd Z d S)rrtype[Namespace[Any]]c>|tjurddlm}|Sddlm}|S)Nr)rJ)rMAINnarwhals._namespacerJnarwhals.stable.v1._namespace)rrJs rz namespacezVersion.namespaces? 7<   5 5 5 5 5 5 ;;;;;;ryrYc>|tjurddlm}|Sddlm}|S)Nr)dtypes)rrnarwhalsrnarwhals.stable.v1)rr v1_dtypess rzrzVersion.dtypess> 7<   ' ' ' ' ' 'M::::::rytype[DataFrame[Any]]c>|tjurddlm}|Sddlm}|S)Nr)rO)rrnarwhals.dataframerOr)rrO DataFrameV1s rz dataframezVersion.dataframe? 7<   4 4 4 4 4 4 ??????rytype[LazyFrame[Any]]c>|tjurddlm}|Sddlm}|S)Nr)rP)rrrrPr)rrP LazyFrameV1s rz lazyframezVersion.lazyframerrytype[Series[Any]]c>|tjurddlm}|Sddlm}|S)NrrS)rrnarwhals.seriesrTr)rrTSeriesV1s rzserieszVersion.seriess= 7<   . . . . . .M999999ryN)rr)rrY)rr)rr)rr) rtrurvrV1rrrrrrrrxryrzrrs B 466D XXXXXryrc"eZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z d-dZed.dZed/dZed0dZd1dZd2dZd2dZd2dZd2d Zd2d!Zd2d"Zd2d#Zd2d$Zd2d%Zd2d&Zd2d'Z d2d(Z!d2d)Z"d3d+Z#d,S)4rz?Implementation of native object (pandas, Polars, PyArrow, ...).pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframezpyspark[connect]unknownrrqc*t|jSr)rqvaluers rz__str__zImplementation.__str__s4:rycls type[Self]native_namespacer9cVttjttjt tjttjttj ttj ttjttjt#tjt'tjt+tji }||tjS)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. Returns: Implementation. )r%rPANDASr$MODINrCUDFr'PYARROWr*PYSPARKr&POLARSr!DASKr"DUCKDBr#IBISr+SQLFRAMEr)PYSPARK_CONNECTgetUNKNOWN)rrmappings rzfrom_native_namespacez$Implementation.from_native_namespaces LL./ KK- JJ+ MM>1   ~5 LL./  ."5 LL./ JJ+ NNN3  ! !>#A  {{+^-CDDDry backend_namecR ||S#t$rtjcYSwxYw)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. Returns: Implementation. ) ValueErrorrr)rrs rz from_stringzImplementation.from_string6sA *3|$$ $ * * *!) ) ) ) *s &&backend!str | Implementation | ModuleTypect|tr||n+t|tr|n||S)zInstantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. Returns: Implementation. ) isinstancerqrrr)rrs rz from_backendzImplementation.from_backendGsU'3'' 4COOG $ $ $'>224**733  ryc|tjurddl}|S|tjur ddl}|jS|tjurddl}|S|tjurddl}|S|tj ur ddl }|j S|tj urddl }|S|tjur ddl}|jS|tjurddl}|S|tjurddl} | S|tjurddl} | S|tjurddl}|j jSd} t5| )zyReturn the native namespace module corresponding to Implementation. Returns: Native module. rNzNot supported Implementation)rrrr modin.pandasrrrrr pyspark.sqlsqlrrrdask.dataframerrrrrrrrpyspark.sql.connectconnectAssertionError) rpdrrparplrrrrmsgs rzto_native_namespacez"Implementation.to_native_namespace[so >( ( (    I >' ' '    <  >& & & KKKK >) ) ) I >) ) )    ;  >( ( (    I >& & & ! ! ! !> ! >( ( ( MMMM >* * * OOOO >& & & KKKK >1 1 1 & & & &;& &,S!!!ryboolc|tjuS)a^Return whether implementation is pandas. Returns: Boolean. 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 )rrrs rz is_pandaszImplementation.is_pandas~,,,rycL|tjtjtjhvS)asReturn whether implementation is pandas, Modin, or cuDF. Returns: Boolean. 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 )rrrrrs rzis_pandas_likezImplementation.is_pandas_likes-~/C^EXYYYrycL|tjtjtjhvS)apReturn whether implementation is pyspark or sqlframe. Returns: Boolean. 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 rz is_spark_likezImplementation.is_spark_likes(  "  #  *   ryc|tjuS)a^Return whether implementation is Polars. Returns: Boolean. 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 rz is_polarszImplementation.is_polarsrryc|tjuS)a[Return whether implementation is cuDF. Returns: Boolean. 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 )rrrs rzis_cudfzImplementation.is_cudf~***ryc|tjuS)a]Return whether implementation is Modin. Returns: Boolean. 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 )rrrs rzis_modinzImplementation.is_modins~+++ryc|tjuS)aaReturn whether implementation is PySpark. Returns: Boolean. 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 rz is_pysparkzImplementation.is_pyspark~---ryc|tjuS)aiReturn whether implementation is PySpark. Returns: Boolean. 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 rzis_pyspark_connectz!Implementation.is_pyspark_connect s~555ryc|tjuS)aaReturn whether implementation is PyArrow. Returns: Boolean. 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 rz is_pyarrowzImplementation.is_pyarrowrryc|tjuS)a[Return whether implementation is Dask. Returns: Boolean. 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 rzis_daskzImplementation.is_dask)rryc|tjuS)a_Return whether implementation is DuckDB. Returns: Boolean. 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 rz is_duckdbzImplementation.is_duckdb9rryc|tjuS)a[Return whether implementation is Ibis. Returns: Boolean. 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 rzis_ibiszImplementation.is_ibisIrryc|tjuS)acReturn whether implementation is SQLFrame. Returns: Boolean. 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 rz is_sqlframezImplementation.is_sqlframeYs~...ryrcP|}|tjtjtjtjhvr|}nQ|tjtjhvrt }n(|tjurt}n ddl}|j }t|SNr) rrrrrrr(r sqlframe._versionr parse_version)rr into_versionrs rzrzImplementation._backend_versionis))++   "  *    #    "LL n,n.LM M M&==LL ^( ( (#::LL $ $ $ $#,L\***ryNrrq)rrrr9rr)rrrrqrr)rrrrrr)rr9)rr)rr)$rtrurvrrrrrrrrrrrrrr classmethodrrrrrrr r rrrrrrrrr rrxryrzrrs#II F E DG!G! F D F DH"(O)G!EEE[E4***[*    [ &8"8"8"8"t---- ZZZZ     (---- ++++ ,,,, .... 6666 .... ++++ ---- ++++ //// ++++++ryr)r) ) )r))rr))i))r)rz%dict[Implementation, tuple[int, ...]] MIN_VERSIONSimplementationbackend_versionrrNonec`|t|x}krd|d|d|}t|dS)NzMinimum version of z supported by Narwhals is z , found: )r4r)r5r6 min_versionrs rzvalidate_backend_versionr:sLn)EE+FFuNuukuudsuuooGFrytextrqprefixc^||r|t|dS|Sr) startswithlen)r;r<s rz remove_prefixr@s0 v#CKKMM"" Krysuffixc`||r|dt| S|Sr)endswithr?)r;rAs rz remove_suffixrDs2 }}V$Ns6{{lN## Kryargsr list[Any]ctt|dkrt|dr|dn|S)Nr1r)listr? _is_iterable)rEs rzflattenrJs6 CIINN|DG/D/DNQ4 P PPryargcDt|ttfs|fS|Sr)rrHtuple)rKs rztupleifyrNs$ cD%= ) )v JryAny | Iterable[Any]rcddlm}t|st|r"dt |d}t |t x}Jt||j|j|j |j fr"dt |d}t |t|tot|tt|f S)NrrSz(Expected Narwhals class or scalar, got: z2. Perhaps you forgot a `nw.from_native` somewhere?z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?)rrTr0r3qualified_type_name TypeErrorr&rExprrOrPrrqbytes)rKrTrrs rzrIrIs&&&&&&3#3C#8#8H9LS9Q9QHHHnnll'J bi", =--' 37J37O7O 3 3 3 nn c8 $ $ RZc5&=Q-R-R)RRryversion#str | ModuleType | _SupportsVersionct|tr|n|j}tjdd|}t d|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|V(dS)z\DrXN)intresub).0vs rz z parse_version..s8KKqRVE2q))**KKKKKKry.)rrqrrr[r\rMsplit)rU version_strs rzr$r$s](55N''7;NK&[99K KKK4E4Ec4J4JKKK K KKry obj_or_clstype cls_or_tupletype[_T]TypeIs[type[_T]]cdSrrxrcres rzisinstance_or_issubclassrjs sry object | typeTypeIs[_T | type[_T]]cdSrrxris rzrjrjs  Crytuple[type[_T1], type[_T2]]TypeIs[type[_T1 | _T2]]cdSrrxris rzrjrjs "cry#TypeIs[_T1 | _T2 | type[_T1 | _T2]]cdSrrxris rzrjrjs +.#ry&tuple[type[_T1], type[_T2], type[_T3]]TypeIs[type[_T1 | _T2 | _T3]]cdSrrxris rzrjrjs %(Cry/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]]cdSrrxris rzrjrjs 7:crytuple[type, ...] TypeIs[Any]cdSrrxris rzrjrjs #rycddlm}t||rt||St||p$t|tot ||S)NrrQ)narwhals.dtypesrRrrd issubclass)rcrerRs rzrjrjsi%%%%%%*e$$4*l333 j, / / :t$$MJ )M)Mryitems Iterable[Any]cddlmmtfd|Dstfd|DrdSdd|D}t |)NrrNc38K|]}t|VdSrr)r]itemrOs rzr_z$validate_laziness..s- 9 94:dI & & 9 9 9 9 9 9ryc38K|]}t|VdSrr)r]rrPs rzr_z$validate_laziness..s- : :DJtY ' ' : : : : : :ryzGThe items to concatenate should either all be eager, or all lazy, got: c,g|]}t|Srx)rd)r]rs rz z%validate_laziness.. s#TrTrTrdhUYZ^U_U_TrTrTrry)rrOrPallrR)r~rrOrPs @@rzvalidate_lazinessrs77777777 9 9 9 95 9 9 999 : : : :E : : :::  tTrTrlqTrTrTr t tC C..rylhsrhs-Series[Any] | DataFrame[Any] | LazyFrame[Any]c ddlm}ddlm}dd}t d|}t d|}t t |d d |rt t |d d |r||jjj ||jjj | |j |jjj |jjj St t |d d |rt t |d d |r||jjj ||j jj | |j |jjj |j jj St t |d d |rt t |d d |r||j jj ||jjj | |j |j jj |jjj St t |d d |rt t |d d |r||j jj ||j jj | |j |j jj |j jj St|t|kr1d 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)PandasLikeSeriesindexrrr7c6|jsd}t|dS)Nz'given index doesn't have a unique index) is_uniquer)rrs rz_validate_indexz*maybe_align_index.._validate_index3s' ";CS// ! " "ry_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrrr7)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrrrgetattrrrr_with_compliant _with_nativelocrr?r)rrrrrlhs_anyrhs_anyrs rzmaybe_align_indexrsBDCCCCC======"""" 5#G5#G+T224G  WW&8$??AT U U   07=>>>07=>>>&&  $ 1 1(/3G4L4S4YZ     +T224G  WW&94@@BR S S   07=>>>18>???&&  $ 1 1(/3-4:     ,d335E  WW&8$??AT U U   18>???07=>>>&&  % 2 2)04,39     ,d335E  WW&94@@BR S S   18>???18>???&&  % 2 2)04-4:      7||s7||##hs7||hhZ]^eZfZfhhoo Jryobj-DataFrame[Any] | LazyFrame[Any] | Series[Any]rctd|}|}t|st|r|jSdS)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_nativer1r2r)robj_any native_objs rzmaybe_get_indexrnsR:5#G""$$J ++ /DZ/P/P  4ry)r column_namesstr | list[str] | Noner6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonecddlmtd|}|}||d}t||s|d}t||+t |rfd|Dn |d }n|}t |r@||j| |St|ridd l m }|rd }t|||||j j |j j }||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. 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 providedc*g|]}|dS)T pass_throughrx)r]idxrs rzrz#maybe_set_index..s( @ @ @3YYs . . . @ @ @ryTr) set_indexz/Cannot set index using column names on a Series)r5r6)narwhals.translaterrrrIr1rrrrr2narwhals._pandas_like.utilsrrr) rrrdf_anyrrkeysrrs @rzmaybe_set_indexrs^-,,,,, %  F!!##JE$5Hoo EMCoo E"" 5 @ @ @ @% @ @ @ @5t444   ++%%  # 0 01E1Ed1K1K L L    z * *999999  "CCS// !Y  0@1B    %%f&>&K&KJ&W&WXXX ryc&td|}|}t|rg|}t ||r|S||j|dSt|rg|}t ||r|S||j |dS|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) rrr1__native_namespace___has_default_indexrrr reset_indexr2r)rrrrs rzmaybe_reset_indexrs>5#G""$$J ++ "7799 j*: ; ; N&&  $ 1 1*2H2Hd2H2S2S T T   Z(( "7799 j*: ; ; N&&  % 2 2:3I3It3I3T3T U U    NryrTypeIs[pd.RangeIndex]c,t||jSr)r RangeIndex)rrs rz_is_range_indexrs c+6 7 77rynative_frame_or_seriespd.Series[Any] | pd.DataFramec|j}t||o-|jdko"|jt |ko |jdkS)Nrr1)rrstartstopr?step)rrrs rzrr#sS # (E/00  K1   J#e** $  J!O rykwargs bool | strc jtd|}|}t|r8||j|j|i|St|r8||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) rrr1rrrconvert_dtypesr2r)rrErrrs rzmaybe_convert_dtypesr/sH5#G""$$J ++ &&  $ 1 1) )4:6::     Z(( &&  % 2 2) )4:6::     NryszrZunitr^ int | floatc~|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. >brT>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got )r)rrrs rz scale_bytesrds ~ $ $ $Dy $ $ $G| $ $ $G| $ $ $G|TDTTooryr Series[Any]cDddlm}|jjj}|j}d}t ||r-t |j|jr|jj d}n|j|j krd}n|j|jkrd}n| }t|rtd|jjdk}nZt|rt!|jj}n1t'|r"ddlm}||jo |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="physical")) 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) True r)InterchangeSeriesF is_orderedTzpl.Categoricalphysical) is_dictionary)narwhals._interchange.seriesrrrrrdtype Categoricalrdescribe_categoricalrrr4rorderingr2rcatorderedr5narwhals._arrow.utilsrrd)rrrrresultrrs rzis_ordered_categoricalr}sIT?>>>>>  % . 5F(IF).//HJ f(55H!6|D  $ $ + + +!!## F # # H*FL99BjPFF "6 * * H&*,--FF %f - - H ; ; ; ; ; ;"]6;//GFK4GF Mryn_bytesrrcJd}t|dt||S)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versions1.13.0r)rr)issue_deprecation_warninggenerate_temporary_column_name)rrrs rzgenerate_unique_tokenrs4 ?cH5555 )'7 K K KKrycxd} t|}||vr|S|dz }|dkrd|d|}t|8)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 rTr1dzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )r r)rrcountertokenrs rzrrsv,G &'""   L1  S==333)033 !%% % &ryframesubset Iterable[str]strict list[str]c|s4tt|j|St|}t ||jx}r||S)N) available)rHsetr intersectioncheck_columns_exist)rrrto_droperrors rzparse_columns_to_droprsc =C &&33F;;<<<6llG#Gu}EEEEu NrysequenceSequence[_T] | AnyTypeIs[Sequence[_T]]cXt|tot|t Sr)rrrq)rs rzis_sequence_but_not_strrs$ h ) ) K*Xs2K2K.KKryTypeIs[_SliceNone]cRt|to|tdkSr)rslicers rz is_slice_noners" c5 ! ! 8cU4[[&88ryCTypeIs[SizedMultiIndexSelector[Series[Any] | CompliantSeries[Any]]]ct|o@t|dkrt|dtpt|dkp,t |pt |pt |Sr")rr?rrZr/r-is_compliant_series_intrs rzis_sized_multi_index_selectorr s $C ( ( Pc((Q,::c!fc#:#:NCA  ( ! % %  ( "# & &  ( #3 ' 'ry-TypeIs[Sequence[_T] | Series[Any] | _1DArray]czt|p,t|pt|pt|Sr)rr.r,is_compliant_seriesrs rzis_sequence_likersF $$ $ S ! ! $ c " " $ s # # ryTypeIs[_SliceIndex]ct|to_t|jtpEt|jtp+t|jto|jduo|jduSr)rrrrZrrrs rzis_slice_indexrsj c5 ! ! 39c"" R ch $ $ R sx % % P#)t*; PD@Pry TypeIs[range]c,t|tSr)rrangers rzis_ranger&s c5 ! !!ryTypeIs[SingleIndexSelector]crtt|tot|t Sr)rrrZrs rzis_single_index_selectorr*s,  3$$BZT-B-B)B C CCryTTypeIs[SingleIndexSelector | MultiIndexSelector[Series[Any] | CompliantSeries[Any]]]c\t|pt|pt|Sr)rr rrs rzis_index_selectorr.s4 !%%  ( - -  #  rytpTypeIs[list[_T]]cvtt|to|ot|d|Sr")rrrH)rrs rz is_list_ofr 8s2  3%%H#H*SVR2H2H I IIryctt|o.tt|dx}ot ||Sr)rrnextiterr)rrfirsts rzis_sequence_ofr%=sN $$ "499d++ +U " ub ! !  rycxddl}ddlm}ddl}t ||jj}|}d} |rg||}| |s-t|j ddx}r"| dr |j }|dz }nn|g ~n#~wxYw|S)zFind the first place in the stack that is not inside narwhals. Returns: Stacklevel. Taken from: https://github.com/pandas-dev/pandas/blob/ab89c53f48df67709a533b6a95ce3d911871a0a8/pandas/util/_exceptions.py#L30-L51 rN)Path co_qualnamezsingledispatch.r1) inspectpathlibr'rrq__file__parent currentframegetfiler>rf_codef_back)r)r'nwpkg_dirrnfnamequalnames rzfind_stacklevelr6FsNNN$$r{##*++G  " "E A OOE**E(( $U\=$GGG ''(9::   Q   EE Hs A*B44B7messagercLt|ttdS)zIssue a deprecation warning. Arguments: message: The message associated with the warning. _version: Narwhals version when the warning was introduced. Just used for internal bookkeeping. )r7category stacklevelN)rDeprecationWarningr6)r7rs rzrrps& #5/BSBSTTTTTTry bool | Nonerpass_through_defaultemit_deprecation_warningcz|||}n3|||rd}t|d| }n||nd}t||S)Nz`strict` in `from_native` is deprecated, please use `pass_through` instead. Note: `strict` will remain available in `narwhals.stable.v1`. See https://narwhals-dev.github.io/narwhals/backcompat/ for more information. rrz,Cannot pass both `strict` and `pass_through`)rr)rrr=r>rs rzvalidate_strict_and_pass_thoughr@{su~,.+   4 # >b  &cH = = = =!z L4 <oo ryrXF) warn_versionrequiredrArB*Callable[[Callable[P, R]], Callable[P, R]]cdfd }|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]rcDtdfd }|S) NrEP.argskwdsP.kwargsrrlc|dd}|dd}||rd}t||}n5||d}t|||rdjd}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`.)poprrrt)rErIrrrrErBrAs rzwrapperz=deprecate_native_namespace..decorate..wrappershhy$//G#xx(:DAA +Jj .cLIIII*!-'2EH oo%!)go(oHHHH oo%%DO2t$t$$ $ry)rErHrIrJrrlr)rErMrBrAs` rzdecoratez,deprecate_native_namespace..decoratesC r % % % % % % %  %*ry)rErFrrFrx)rArBrNs`` rzdeprecate_native_namespacerOs.2 Ory window_size min_samples int | Nonetuple[int, int]ct|tdt|ttdd|dkrd}t||/|dkrd}t|||krd}t |n|}||fS)NrP param_namerQr1z+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_typerZrdrr8)rPrQrs rz_validate_rolling_argumentsrXs S];;;; S$t**GGGGQ;oo ???CS// !  $ $JC',, , %"  ##ryheader native_reprc  tjj}n2#t$r%t tjdd}YnwxYw|}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)NCOLUMNSPc34K|]}t|VdSr)r?)r]lines rzr_z generate_repr..s(>>3t99>>>>>>ryu┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorrZgetenv expandtabs splitlinesmaxr?) rYrZterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrar_diffs rz generate_reprrusE7-//7 777RYy"55667))++6688L>>>>>>>!~--%s6{{33,uv~,,,F + jc\Q./jj PQ@QT`cdTd@d9ejjjj)cVn)))) 00Q6 ..14AQ8QUV7VV   k kD j#-jtjSIHXz1check_column_names_are_unique..s#@@@tq!!a%%a%%%ryrXc3.K|]\}}d|d|dVdS)z - 'z' z timesNrxr~s rzr_z0check_column_names_are_unique..s:LLA,a,,1,,,LLLLLLryz"Expected unique column names, got:)r?r collectionsr|r~joinr7)rlen_unique_columnsr|r duplicatesrs rzcheck_column_names_are_uniquersS\\** 7||)))''''''''""@@w}}@@@ ggLL9I9I9K9KLLLLL8388S!!!*)ry time_unit$TimeUnit | Iterable[TimeUnit] | None time_zone7str | timezone | Iterable[str | timezone | None] | None%tuple[Set[TimeUnit], Set[str | None]]c|hdn&t|tr|hnt|}|dhn7t|ttfrt|hn d|D}||fS)N>smsnsusc4h|]}|t|ndSr)rq)r]tzs rz z1_parse_time_unit_and_time_zone..s& F F Fbc"gggT F F Fry)rrqrr)rr time_units time_zoness rz_parse_time_unit_and_time_zoner s    i % %i[[ ^^     i#x 1 1Gc)nn   F FI F F F  z !!ryrrRrrYr Set[TimeUnit]rSet[str | None]cjt||jo|j|vo|j|vp d|vo|jduS)N*)rDatetimerr)rrrrs rz%dtype_matches_time_unit_and_time_zonersR 5&/** _ *  Oz ) Cz!AeoT&A ryc|jSrr)rs rzget_column_namesr,s =rynamesContainer[str]c*fd|jDS)Ncg|]}|v| Srxrx)r]col_namers rzrz(exclude_column_names..1s# L L Lhe6K6KH6K6K6Kryr)rrs `rzexclude_column_namesr0s L L L LU] L L LLryEvalNames[Any]cdfd }|S)N_framerrrcSrrx)rrs rzrEz$passthrough_column_names..fn5s ry)rrrrrx)rrEs` rzpassthrough_column_namesr4s( IryattrcDt}t||||uSr)objectr )rrsentinels rz_hasattr_staticr;s"xxH #tX . .h >>ry[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co] | Any]TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co]]c"t|dS)N__narwhals_dataframe__rrs rzis_compliant_dataframer@s 3 8 9 99ryICompliantLazyFrame[CompliantExprT, NativeFrameT_co, ToNarwhalsT_co] | AnyKTypeIs[CompliantLazyFrame[CompliantExprT, NativeFrameT_co, ToNarwhalsT_co]]c"t|dS)N__narwhals_lazyframe__rrs rzis_compliant_lazyframerKs 3 8 9 99ry'CompliantSeries[NativeSeriesT_co] | Any)TypeIs[CompliantSeries[NativeSeriesT_co]]c"t|dS)N__narwhals_series__rrs rzrrQs 3 5 6 66rycRt|o|jSr)rr is_integerrs rzr r Ws% s # # > (<(<(>(>>ryECompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co] | AnyGTypeIs[CompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co]]c"t|dS)N__narwhals_expr__hasattrrs rzis_compliant_exprr]s 3+ , ,,ry"TypeIs[EagerAllowedImplementation]cx|tjtjtjtjtjhvSr)rrrrrrrs rzis_eager_allowedrcs2   ryTypeIs[SupportsNativeNamespace]c"t|dS)Nrrrs rzhas_native_namespacerms 3. / //ryTypeIs[DataFrameLike]c"t|dS)N __dataframe__rrs rz_supports_dataframe_interchangerqs 3 ( ((ryTypeIs[ArrowStreamExportable]c"t|dS)N__arrow_c_stream__rrs rzsupports_arrow_c_streamrus 3 4 5 55ryleft_onright_ondict[str, str]c^fd|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. c30K|]}|vr|n|VdSrrx)r]keyrrAs rzr_z(_remap_full_join_keys..sL8;C7NN3ry)dictzip)rrrAright_keys_suffixeds` ` rz_remap_full_join_keysrysM ?G H122 3 33rydatarLcontextpa.TablectdrLddl}ddlm}|j}|t ||}|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. rrN)ArrowNamespace)r6rU)rzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type r`) r rnarwhals._arrow.namespacerrr$ _dataframe from_arrowrrQModuleNotFoundError)rrrrrUrrs rz_into_arrow_tablers '<<<<<<" ^M",=,=w O O O}''b'99@@qSfgkSlSlqqq!#&&&ryrEc|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) rx)rEs rzunstablers ( Iryformatc<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|]}|vV dSrrx)r]xrs rzr_z#_is_naive_format..s'::11;::::::ry)z%sz%zZ)any)rs`rz_is_naive_formatrs,::::(9::::: ::rycXeZdZdZdddZdd Zdd Z dddZddZe d dZ 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 | Nonerr7c||_dSr)_alias)rrs rz__init__znot_implemented.__init__s#( ryrqcPdt|jd|jd|jS)N: r`)rdrt _name_owner_namers rz__repr__znot_implemented.__repr__s.J4::&JJ4+;JJdjJJJryr~rfnamec:|j|_|jp||_dSr)rtrrr)rr~rs rz __set_name__znot_implemented.__set_name__s %+- ryr}_T | Literal['raise'] | Nonetype[_T] | Nonerc`||St|d|j}t|j|)Nr)rr_not_implemented_errorr)rr}r~whos rzrznot_implemented.__get__s:  Kh 143CDD$TZ555ryrErIc,|dS)Nraise)r)rrErIs rz__call__znot_implemented.__call__s||G$$$ryr7r<r>cF|}t||S)aAlt constructor, wraps with `@deprecated`. Arguments: message: **Static-only** deprecation message, emitted in an IDE. Returns: An exception-raising [descriptor]. [descriptor]: https://docs.python.org/3/howto/descriptor.html r)rr7rs rzrznot_implemented.deprecateds'cee"z'""3'''ryr)rrrr7r&)r~rfrrqrr7)r}rr~rrr)rErrIrrr)r7r<rr>) rtrurvrrrrrr r'rrxryrzrrs""H((((( KKKK.... PT 6 6 6 6 6%%%%  ( ( ([ ( ( (ryrwhatrNotImplementedErrorc0|d|d}t|S)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 rrs rzrr%s:  S SC S S S s # ##rycjeZdZUdZded<ded<eddd Zedd ZddZ ddZ 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_versionrq_hintrXhintminimumrr>cL||}||_||_|S)zMethod decorator for raising below a minimum `_backend_version`. Arguments: minimum: Minimum backend version. hint: Optional suggested alternative. Returns: An exception-raising decorator. )__new__rr)rrrrs rzr6zrequires.backend_versionHs)kk#"  ryr6c@dd|DS)Nr`c3K|]}|VdSrrx)r]ds rzr_z,requires._unparse_version..Zs$8811888888ry)r)r6s rz_unparse_versionzrequires._unparse_versionXs#xx88888888ryr}rr7c  |j|jkrdS|j}|j}||j}||j}d|d|d|d|d }|jr |d|j}t |)N`z` is only available in 'z>=z', found version r` )rr _wrapped_namerrrr )rr}methodrrfoundrs rz_ensure_versionzrequires._ensure_version\s  $(9 9 9 F#*''(9::%%h&?@@a&aa'aaWaaW\aaa : )((DJ((C!#&&&ryrE_Method[_ContextT, P, R]cZj_td fd }|S) Nr}rrErHrIrJrrlcF||g|Ri|Sr)r )r}rErIrErs rzrMz"requires.__call__..wrapperks7   * * *2h...... .ry)r}rrErHrIrJrrl)rtrr)rrErMs`` rzr zrequires.__call__hsH[ r / / / / / /  / ryN)rX)rrqrrrr>)r6rrrq)r}rrr7)rEr!rr!) rtrurvrrwr'r6 staticmethodrr r rxryrzrr.s,"!!!JJJ    [ 999\9 ' ' ' '      ryr str_slicerc"tuple[int | None, int | None, Any]c|j||jnd}|j||jdznd}|j}|||fS)Nr1)rrrr)r%rrrrs rzconvert_str_slice_to_int_slicer(ts\/8o.IGMM)/ * * *tE090J7== ( (1 , ,PTD >D 4 ry tp_parentCallable[P, R1].decorates  * , ,DOOT1R1R ,!' !2!2J  )[)))%2))$))  C.. ry)r-r.rr.rx)r)rNs` rzr0r0}s( ! ! ! ! ! ! Oryobject | type[Any]ct|tr|nt|}|jdkr|jnd}|d|jdS)NbuiltinsrXr`)rrdrurtlstrip)rrmodules rzrQrQs[3%% 4499B mz99R]]rF $ $r{ $ $ + +C 0 00ryrU valid_types type[Any]rVct||sdd|D}d|dt|}|rnd}t|}t |dkrt|d}||d}d t |zd t |zz}|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 | c34K|]}t|VdSr)rQ)r]rs rzr_zensure_type..s+LL"1"55LLLLLLryz Expected z, got: z (z(...)=rb^rN)rrrQreprr?rR) rrVr6tp_namesrleft_padvalassign underlines rzrWrWsB c; ' ' ::LL LLLLLI(II-@-E-EII  7Hs))C3xx"}},S11888 /*///Fs6{{*sSXX~>I66F6C66966Cnn  ryc*eZdZdZd dZd dZdd Zd S)_DeferredIterablezLStore a callable producing an iterable to defer collection until we need it. into_iterCallable[[], Iterable[_T]]rr7c||_dSr _into_iter)rrEs rzrz_DeferredIterable.__init__s 6?ry Iterator[_T]c#>K|Ed{VdSrrHrs rz__iter__z_DeferredIterable.__iter__s.??$$$$$$$$$$$rytuple[_T, ...]cv|}t|tr|nt|Sr)rIrrM)rits rzto_tuplez_DeferredIterable.to_tuples0 __  E**9rrb 9ryN)rErFrr7)rrJ)rrM)rtrurvrrrLrPrxryrzrDrDsZVV@@@@%%%%::::::ryrD)r5rr6rrr7)r;rqr<rqrrq)r;rqrArqrrq)rErrrF)rKrrr)rKrOrr)rUrVrr)rcrdrerfrrg)rcrkrerfrrl)rcrdrernrro)rcrkrernrrq)rcrdrersrrt)rcrkrersrrv)rcrrerxrry)rcrrerrr)r~rrr7)rrerrrre)rrrrr)rrerrrrrre)rrerre)rrrrrr)rrrrrr)rrerErrrrre)rrZrr^rr)rrrr)rrZrrrrq)rrrrrrrr)rrrr)rrrr)rrrr)rrrr )rrrr)rrrr)rrrr)rrrr)rrrrfrr)rrrrfrr)rrZ)r7rqrrqrr7) rr<rr<r=rr>rrr)rArqrBrrrC)rPrZrQrRrrS)rYrqrZrqrrq)rrrrrrv)rrrr7)rrrrrr) rrRrrYrrrrrr)rrrr)rrrrrr)rrrr)rrrrqrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrrrArqrr)rrLrrrr)rErjrrj)rrqrr)r rqrrqrr )r%rcrrrr&)r)r*rr+)rr1rrq)rrr6r7rVrqrr7) __future__rrer[datetimerenumrr functoolsrimportlib.utilr r)r r secretsr typingr rrrrrrrrrrrrrwarningsrnarwhals._enumrnarwhals._typing_compatrnarwhals.dependenciesrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5narwhals.exceptionsr6r7r8typesr9r:Setrrrrrrtyping_extensionsr;r<r=r>r?r@narwhals._compliantrArBrCrDrErFrGnarwhals._compliant.typingrHrrIrJnarwhals._translaterKrLrMrrOrPr|rRrrTnarwhals.typingrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrergrhrirjrkrlrmrnrpr|rrrrrrrrrrrrwrrrrrrrrrrrrrrrrr4r:r@rDrJrNrIr$rjrrrrrrrrrrrrrrrr rrrrrr r%r6rr@rOrXrurrrrrrrrrrrr rrrrrrrrrrrrr(r0rQrWrDrxryrzrds[""""""" $$$$$$******** %%%%%%......2[ZZZZZZZZZb0      ))))))544444IIIIIIIIYYYYYYYYYY77777777%%%%%%&&&&&&&WininfSk&Q RN '%..C '%..C '%..C '%3 4 4 4C #A A B B8RRRRRxRRRNNNNNNNN2222222211111111     /        ,ox   00000000  WT]] W\T 2 2 2 4888 GK~ 6 6 6 =====< <<<<      HZ(          x .    44444d444n+++++Z+++F :*EF"F:4Z 7      QQQQ SSSS(LLLL"          """ "  ... .  ((( (  ::: :    \\\\~!!!!L,0XEI XXXXXXv////d8888    2222j2BBBBJLLLL"&"&"&"&JLLLL9999    """"DDDDJJJJ ' ' ' ' TUUUU6&&&&&&R$$$$0< " " " """""*    MMMM???? :::::::: 7777 ???? ---- 0000))))66664444,''''2.;;;;$Q(Q(Q(Q(Q(Q(Q(Q(h$$$$CCCCCCCCL81111 IK,,,,,,^ : : : : : : : : : :ry