hy\ %SSKJr SSKrSSKrSSKJrJrJrJrJ r J r SSK J r SSK JrJr SSKJrJrJr SSKJr SSKJrJr SS KJr SS KJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r% SS K&J'r' SS K(J)r) SS K*J+r+J,r, SSK-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@ SSKAJBrBJCrCJDrD \(Ga SSKJErE SSKFJGrG SSKHrISSKJrKSSKLrMSSKNJOrOJPrPJQrQJRrRJSrSJTrT SSKUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\ SSK]J^r^ SSK_J`r`Jara SSKbJcrcJdrdJere SSKfJgrgJhrh SSKiJjrj SSKkJlrl SSKmJnrnJoroJprpJqrqJrrrJsrsJtrtJuruJvrvJwrwJxrxJyryJzrzJ{r{J|r|J}r} \""S\#\h\\g\\l\4S9r~\""S5r\""S5r\""S5r\""S 5r\""S!5r\""S"5r\""S#5r\""S$S%S9r\Q"S&5r\""S'5r\""S(5r\""S)5r"S*S+\!5r"S,S-\!5r"S.S/\!5r\""S05r\""S1S2S39r\""S4S2S39r\""S5S6S9rS7rS8\S9'S:rS8\S;'"S<S=\!\5r"S>S?\!\5r"S@SA\!5r"SBSC\!5r"SDSE\!5r"SFSG\\\!5r"SHS6\\\!5r"SISJ\\!5r"SKSL\5r"SMSN\'5r\GR>SO\GR@SP\GRBSQ\GRDSR\GRFSS\GRHSS\GRJST\GRLSU\GRNSV\GRPSW\GRRSX0 rSY\SZ'\GRLS[\GR@S\\GRFS]\GRHS^0rS_\S`'\"SaSb9SScj5r\SSdj5rSSejrSSfjrSSgjrSShjr\%SSij5r\%SSjj5r\%SSkj5r\%SSlj5r\%SSmj5r\%SSnj5r\%SSoj5r\%SSpj5r\%SSqj5r\%SSrj5r\%SSsj5r\%SStj5r\%SSuj5r\%SSvj5r\%SSwj5rSSxjrSSyjrSSzjrSS{jrSSS|.SS}jjjrSS~jrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSS.SSjjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjr"SS5rSSjr"SS5rSSjrGSSjrGSSjrSS.GSSjjr"SS\\5rg() annotationsN) Collection ContainerIterableIteratorMappingSequence)timezone)Enumauto)cache lru_cachewraps) find_spec)getattr_staticgetdoc) token_hex) TYPE_CHECKINGAnyCallableGenericLiteralProtocolTypeVarUnioncastoverload) NoAutoEnum)issue_deprecation_warning) assert_never deprecated)get_cudfget_dask_dataframe get_duckdbget_ibis get_modin get_pandas get_polars get_pyarrowget_pyspark_connectget_pyspark_sql get_sqlframeis_narwhals_seriesis_narwhals_series_intis_numpy_array_1dis_numpy_array_1d_intis_pandas_like_dataframeis_pandas_like_seriesis_polars_seriesis_pyarrow_chunked_array)ColumnNotFoundErrorDuplicateErrorInvalidOperationError)Set) ModuleType) 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_T4_T5_T6_T7_FnzCallable[..., Any]PRR1R2c \rSrSr%S\S'Srg)_SupportsVersionvstr __version__N__name__ __module__ __qualname____firstlineno____annotations____static_attributes__rwbC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\narwhals/_utils.pyrsrsvsrrsc"\rSrSrSSSjjrSrg) _SupportsGetyNcgNrw)selfinstanceowners r__get___SupportsGet.__get__zscrrwr)rrr Any | Nonereturnr)ryrzr{r|rr~rwrrrrysQQrrc(\rSrSr\SSj5rSrg)_StoresColumns|cgrrwrs rcolumns_StoresColumns.columns}s,/rrwN)r Sequence[str])ryrzr{r|propertyrr~rwrrrr|s / /rr_T NativeT_coT) covariant CompliantT_co _ContextT _FullContextz&Callable[Concatenate[_ContextT, P], R]r>_Methodz Callable[Concatenate[_T, P], R2] _Constructorc,\rSrSrSr\SSj5rSrg) _StoresNativezProvides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table cg)zReturn the native object.Nrwrs rnative_StoresNative.native rrwN)rr)ryrzr{r|__doc__rrr~rwrrrr  rrc,\rSrSrSr\SSj5rSrg)_StoresCompliantzProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame cg)zReturn the compliant object.Nrwrs r compliant_StoresCompliant.compliantrrrwN)rr)ryrzr{r|rrrr~rwrrrrrrrc(\rSrSr\SSj5rSrg)_StoresBackendVersioncg)z#Version tuple for a native package.Nrwrs r_backend_version&_StoresBackendVersion._backend_versionrrrwNrtuple[int, ...])ryrzr{r|rrr~rwrrrrs   rrc \rSrSr%S\S'Srg)_StoresVersionVersion_versionrwNrxrwrrrrs ,rrc \rSrSr%S\S'Srg)_StoresImplementationImplementation_implementationrwNrxrwrrrrs ##Irrc\rSrSrSrSrg)_LimitedContextz9Provides 2 attributes. - `_implementation` - `_version` rwNryrzr{r|rr~rwrrrrsrrc\rSrSrSrSrg)rzNProvides 3 attributes. - `_implementation` - `_backend_version` - `_version` rwNrrwrrrrsrc"\rSrSrSrSSjrSrg)ValidateBackendVersionz=Ensure the target `Implementation` is on a supported version.c8URR5ng)zRaise if installed version below `nw._utils.MIN_VERSIONS`. **Only use this when moving between backends.** Otherwise, the validation will have taken place already. N)rr)r_s r_validate_backend_version0ValidateBackendVersion._validate_backend_versions  1 1 3rrwN)rNone)ryrzr{r|rrr~rwrrrrs G4rrc\rSrSr\"5r\"5r\"5r\S Sj5r \S Sj5r \S Sj5r \S Sj5r \S Sj5r Srg)rc~U[RLaSSKJn U$U[RLaSSKJn U$SSKJn U$)Nr)rI)rV1narwhals.stable.v1._namespacerIV2narwhals.stable.v2._namespacenarwhals._namespace)r NamespaceV1 NamespaceV2rIs r namespaceVersion.namespaces5 7::  N  7::  N 1rc~U[RLaSSKJn U$U[RLaSSKJn U$SSKJn U$)Nr)dtypes)rrnarwhals.stable.v1rrnarwhals.stable.v2narwhals)r dtypes_v1 dtypes_v2rs rrVersion.dtypess4 7::  >  7::  > # rc~U[RLaSSKJn U$U[RLaSSKJn U$SSKJn U$)Nr)rN)rrrrNrrnarwhals.dataframe)r DataFrameV1 DataFrameV2rNs r dataframeVersion.dataframe5 7::  C  7::  C 0rc~U[RLaSSKJn U$U[RLaSSKJn U$SSKJn U$)Nr)rO)rrrrOrrr)r LazyFrameV1 LazyFrameV2rOs r lazyframeVersion.lazyframerrc~U[RLaSSKJn U$U[RLaSSKJn U$SSKJn U$)NrrR)rrrrSrrnarwhals.series)rSeriesV1SeriesV2rSs rseriesVersion.seriess2 7::  =O 7::  =O* rrwN)rztype[Namespace[Any]])rrX)rztype[DataFrame[Any]])rztype[LazyFrame[Any]])rztype[Series[Any]])ryrzr{r|r rrMAINrrrrrrr~rwrrrrsy B B 6D           rrc`\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrS$Sjr\S%Sj5r\S&Sj5r\S'Sj5rS(SjrS)SjrS)SjrS)SjrS)SjrS)SjrS)SjrS)SjrS)SjrS)SjrS)Sjr S)Sjr!S)Sjr"S)S jr#S*S!jr$S"r%g#)+ri!z?Implementation of native object (pandas, Polars, PyArrow, ...).pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframezpyspark[connect]unknownc,[UR5$r)ruvaluers r__str__Implementation.__str__=s4::rcV[5[R[5[R[ 5[R [5[R[5[R[5[R[5[R[5[R [#5[R$['5[R([+5[R,0 nUR/U[R05$)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. Returns: Implementation. )r'rPANDASr&MODINr"CUDFr)PYARROWr+PYSPARKr(POLARSr#DASKr$DUCKDBr%IBISr,SQLFRAMEr*PYSPARK_CONNECTgetUNKNOWN)clsnative_namespacemappings rfrom_native_namespace$Implementation.from_native_namespace@s L.// K-- J++ M>11  ~55 L.//  ."5"5 L.// J++ NN33  !>#A#A  {{+^-C-CDDrcTU"U5$![a [Rs$f=f)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. Returns: Implementation. ) ValueErrorrr)r backend_names r from_stringImplementation.from_string[s- *|$ $ *!)) ) *s  ''c[U[5(aURU5$[U[5(aU$UR U5$)zInstantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. Returns: Implementation. ) isinstancerurrr)rbackends r from_backendImplementation.from_backendlsR'3'' OOG $ '>22 **73  rcU[RLa Sn[U5eUR5 [R XR 5n[U5$)zaReturn the native namespace module corresponding to Implementation. Returns: Native module. z:Cannot return native namespace from UNKNOWN Implementation)rrAssertionErrorr_IMPLEMENTATION_TO_MODULE_NAMErr_import_native_namespace)rmsg module_names rto_native_namespace"Implementation.to_native_namespacesM >)) )NC % % 488zzJ ' 44rc&U[RL$)aReturn 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 r is_pandasImplementation.is_pandas~,,,,rcfU[R[R[R1;$)a#Return 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 ris_pandas_likeImplementation.is_pandas_likes(--~/C/C^EXEXYYYrcfU[R[R[R1;$)a Return 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 )rr rrrs r is_spark_likeImplementation.is_spark_likes1  " "  # #  * *   rc&U[RL$)aReturn 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 )rr rs r is_polarsImplementation.is_polarsr,rc&U[RL$)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 ris_cudfImplementation.is_cudf~****rc&U[RL$)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 ris_modinImplementation.is_modins~++++rc&U[RL$)aReturn 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 )rr rs r is_pysparkImplementation.is_pyspark~----rc&U[RL$)aReturn 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 ris_pyspark_connect!Implementation.is_pyspark_connects~5555rc&U[RL$)aReturn 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 r is_pyarrowImplementation.is_pyarrowr@rc&U[RL$)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 )rr rs ris_daskImplementation.is_dask"r9rc&U[RL$)aReturn 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 )rr rs r is_duckdbImplementation.is_duckdb2r,rc&U[RL$)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 )rr rs ris_ibisImplementation.is_ibisBr9rc&U[RL$)aReturn 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 r is_sqlframeImplementation.is_sqlframeRs~....rc[U5$)zReturns backend version.backend_versionrs rrImplementation._backend_versionbs t$$rrwNrru)r type[Self]rr9rr)rrXrrurr)rrXrz!str | Implementation | ModuleTyperr)rr9)rboolr)&ryrzr{r|rrrrrr r r r r rrrr classmethodrrrr'r*r.r1r4r7r;r>rBrErHrKrNrQrr~rwrrrr!s?I F E DG!G! F D F DH"(O)G!E E+5E EE4* *'** **   "C   & 5- Z  (- + , . 6 . + - + / %rr)r[)r) ) )r\)r)ir])r[))r\rz(Mapping[Implementation, tuple[int, ...]] MIN_VERSIONSzdask.dataframez modin.pandasz pyspark.sqlzpyspark.sql.connectzMapping[Implementation, str]r#)maxsizecSSKJn U"U5$)Nr) import_module) importlibrk)r&rks rr$r$~s'  %%rc([U[5(d [U5 U[RLa Sn[ U5eUn[ R X"R5n[U5nUR5(aSSK nURnOOUR5(dUR5(aSSKnUnOUR5(aSSKnUnOUn[#U5n U [$U=n :aSUSU SU 3n['U5eU $)Nz9Cannot return backend version from UNKNOWN ImplementationrzMinimum version of z supported by Narwhals is z , found: )rrr rr"r#rrr$rQsqlframe._versionrr>rBrrHr parse_versionrgr) implementationr%implr&rr into_versionrrversion min_versions rrUrUs nn 5 5^$///IS!! D044T::FK/ <  ((   d5577  ' L)Gd!33+4#D6)CK=PYZaYbco Nrcn[[U5S:Xa[US5(a US5$U5$)Nr[r)listlen _is_iterable)argss rflattenrzs1 CIN|DG/D/DQ PP4 PPrcB[U[[45(dU4$U$r)rrvtuple)args rtupleifyr~s cD%= ) )v JrcSSKJn [5=nb&[XRUR45(dI[ 5=nbW[XRUR URUR45(aS[U5<S3n[U5e[U[5=(a [U[[U45(+$)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 TypeErrorrrubytes)r}rSpdplr%s rrxrxs&| (Zii=V-W-W| ( sYYr||L M M77J37O6RS3 3 n c8 $ RZc5&=Q-R)RRrc[U[5(aUO URn[R"SSU5n[ SUR S555$)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.*$)c3d# UH&n[[R"SSU55v M( g7f)z\DrN)intresub).0vs r parse_version..s'K4JqRVVE2q)**4Js.0.)rrurvrrr|split)rs version_strs rrorosK(55'7;N;NK&&[9K KK4E4Ec4JK KKrcgrrw obj_or_cls cls_or_tuples risinstance_or_issubclassrsrcgrrwrs rrrs rcgrrwrs rrrs"rcgrrwrs rrr+.rcgrrwrs rrrs%(rcgrrwrs rrrs7:rcgrrwrs rrrrrcgrrwrs rrrs CFrcgrrwrs rrr s14rcgrrwrs rrrs ORrcgrrwrs rrrs7:rcgrrwrs rrrs rcgrrwrs rrr's =@rcgrrwrs rrr0srcgrrwrs rrrBsrcSSKJn [X5(a [X5$[X5=(d" [U[5=(a [ X5$)NrrP)narwhals.dtypesrQrtype issubclass)rrrQs rrrHsA%*$$*33 j / :t$MJ)Mrc^^SSKJmJm [U4SjU55(d[U4SjU55(agSUVs/sHn[ U5PM sn3n[ U5es snf)NrrMc3<># UHn[UT5v M g7frr)ritemrNs rr$validate_laziness..Us 954:dI & &5c3<># UHn[UT5v M g7frr)rrrOs rrrVs :EDJtY ' 'ErzGThe items to concatenate should either all be eager, or all lazy, got: )rrNrOallrr)itemsrr%rNrOs @@rvalidate_lazinessrRsc7 95 999 :E ::: SlqTrlqdhUYZ^U_lqTrSs tC C.UssA*c:SSKJn SSKJn S Sjn[ SU5n[ SU5n[ [ USS5U5(a[ [ USS5U5(aU"URRR5 U"URRR5 URURRURRRURRR55$[ [ USS5U5(a[ [ USS5U5(aU"URRR5 U"URRR5 URURRURRRURRR55$[ [ USS5U5(a[ [ USS5U5(aU"URRR5 U"URRR5 URURRURRRURRR55$[ [ USS5U5(a[ [ USS5U5(aU"URRR5 U"URRR5 URURRURRRURRR55$[U5[U5:wa%S [U5S [U53n[U5eU$) arAlign `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)PandasLikeSeriesrc@UR(d Sn[U5eg)Nz'given index doesn't have a unique index) is_uniquer)indexr%s r_validate_index*maybe_align_index.._validate_indexs;CS/ !r_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_nativelocrrwr)lhsrhsrrrlhs_anyrhs_anyr%s rmaybe_align_indexr]sjBD=" 5#G5#G+T24G WW&8$?AT U U0077==>0077==>&&  $ $ 1 1((//33G4L4L4S4S4Y4YZ   +T24G WW&94@BR S S0077==>1188>>?&&  $ $ 1 1((//33--44::   ,d35E WW&8$?AT U U1188>>?0077==>&&  % % 2 2))0044,,3399   ,d35E WW&94@BR S S1188>>?1188>>?&&  % % 2 2))0044--44::    7|s7|#Fs7|nTYZ]^eZfYgho Jrc[SU5nUR5n[U5(d[U5(a UR$g)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_nativer1r2r)objobj_any native_objs rmaybe_get_indexrsC:5#G""$J ++/DZ/P/P r)rcSSKJn [SU5nUR5nUbUb Sn[U5eU(dUc Sn[U5eUb/[ U5(aUVs/sH os"USS9PM snOU"USS9nOUn[ U5(a9UR URRURU555$[U5(a`SSK J n U(a S n[U5eU "UUURRS 9nUR URRU55$U$s snf) aUSet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: object for which maybe set the index (can be either a Narwhals `DataFrame` or `Series`). column_names: name or list of names of the columns to set as index. For dataframes, only one of `column_names` and `index` can be specified but not both. If `column_names` is passed and `df` is a Series, then a `ValueError` is raised. index: series or list of series to set as index. Returns: Same type as input. Raises: ValueError: If one of the following conditions happens - none of `column_names` and `index` are provided - both `column_names` and `index` are provided - `column_names` is provided and `df` is a Series Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_set_index(df, "b")) # doctest: +NORMALIZE_WHITESPACE a b 4 1 5 2 r)rrz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedT) pass_through) set_indexz/Cannot set index using column names on a Series)rp)narwhals.translaterrrrxr1rrrrr2narwhals._pandas_like.utilsrr) r column_namesrrdf_anyrr%idxkeysrs rmaybe_set_indexrsD^- % F!!#JE$5Ho EMCo E"";@ @%3Ys .% @5t4  ++%%  # # 0 01E1Ed1K L   z * *9 CCS/ !  00@@ %%f&>&>&K&KJ&WXX 3 As$D<c[SU5nUR5n[U5(aYUR5n[ X#5(aU$UR UR RURSS955$[U5(aYUR5n[ X#5(aU$UR URRURSS955$U$)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 rmaybe_reset_indexr:s>5#G""$J ++"779 j ; ;N&&  $ $ 1 1*2H2Hd2H2S T  Z(("779 j ; ;N&&  % % 2 2:3I3It3I3T U   Nrc,[XR5$r)r RangeIndex)rrs r_is_range_indexrls c66 77rcURn[X!5=(aD URS:H=(a. UR[ U5:H=(a UR S:H$)Nrr[)rrstartstoprwstep)native_frame_or_seriesrrs rrrpsT # ( (E0  KK1   JJ#e* $  JJ!O rc f[SU5nUR5n[U5(a:URURR UR "U0UD655$[U5(a:URURR UR "U0UD655$U$)aConvert 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)rrykwargsrrs rmaybe_convert_dtypesr|sH5#G""$J ++&&  $ $ 1 1))4:6:   Z((&&  % % 2 2))4:6:   NrcUS;aU$US;aUS- $US;aUS- $US;aUS- $US;aUS - $S U<3n[U5e) 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. >br>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got r)szunitr%s r scale_bytesrss ~ $ $Dy $ $G| $ $G| $ $G|KD8TorcSSKJn URRRnURnSn[ X15(a@[ UR UR5(aURRSnU$UR UR:XaSnU$UR UR:waSnU$UR5n[U5(a%[SUR 5RS:HnU$[U5(a![!UR"R$5nU$['U5(a5SSKJn U"UR,5=(a UR,R$nU$) 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_categoricalr rr3rorderingr2rYcatorderedr4narwhals._arrow.utilsrr)rrrrresultrrs ris_ordered_categoricalrsJT?  % % . . 5 5F((IF)//J f((55!!66|D M  $ M ++ + M!!# F # #*FLL9BBjPF M #6 * *&**,,-F M &f - - ;"6;;/GFKK4G4GF Mrc,Sn[USS9 [XS9$)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versionsz1.13.0r)n_bytesr)rgenerate_temporary_column_name)r rr%s rgenerate_unique_tokenr s# ?cH5 )' KKrczSnS[US- 53nX1;aU$US- nUS:aSU<SU3n[U5eM9)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 rnwr[dzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr")r rcountertokenr%s rr r sk,G Yw{+,-  L1  S=*L 3 !% % rcU(d-[[UR5RU55$[U5n[ X0RS9=n(aUeU$)N) available)rvsetr intersectioncheck_columns_exist)framesubsetstrictto_droperrors rparse_columns_to_droprAsM C &33F;<<6lG#G}}EEuE NrcZ[U[5=(a [U[5(+$r)rr ru)sequences ris_sequence_but_not_strr Ls h ) K*Xs2K.KKrcL[U[5=(a U[S5:H$r)rslicers r is_slice_noner$Ps c5 ! 8cU4[&88rc [U5=(a= [U5S:=(a [US[5=(d [U5S:H=(d/ [ U5=(d [ U5=(d [ U5$Nr)r rwrrr0r.is_compliant_series_intr#s ris_sized_multi_index_selectorr(Tsl $C ( Pc(Q,::c!fc#:NCA  ( ! %  ( "# &  ( #3 'rc[U5=(d/ [U5=(d [U5=(d [U5$r)r r/r-is_compliant_seriesr#s ris_sequence_liker+bs: $ $ S ! $ c " $ s # rc<[U[5=(a [UR[5=(de [UR[5=(dD [UR [5=(a# URSL=(a URSL$r)rr"rrrrr#s ris_slice_indexr-msh c5 ! 399c" R chh $ R sxx % P#))t*; PD@Prc"[U[5$r)rranger#s ris_ranger0us c5 !!rcl[[U[5=(a [U[5(+5$r)rYrrr#s ris_single_index_selectorr2ys#  3$BZT-B)B CCrc`[U5=(d [U5=(d [U5$r)r2r(r-r#s ris_index_selectorr4}s+ !%  ( -  # rcr[[U[5=(a U=(a [USU55$r&)rYrrv)rtps r is_list_ofr7s)  3%H#H*SVR2H IIrc[[U5=(a) [[U5S5=n=(a [ X!55$r)rYr nextiterr)rr6firsts ris_sequence_ofr<s< $ "49d+ +U " u ! rc`UcUcUnU$Ub Uc U(+nU$UcUbU$Sn[U5e)Nz,Cannot pass both `strict` and `pass_through`r)rrpass_through_defaultr%s rvalidate_strict_and_pass_thoughr?s_ ~,.+     4!z  L4  =orrF) warn_versionrequiredc^^SUU4SjjnU$)a Decorator 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**. c:>^[T5SUUU4Sjj5nU$)Nc>URSS5nURSS5nUbUcT(a Sn[UTS9 UnO;UbUb Sn[U5eUc%Uc"T(aSTRS3n[U5eX!S'T"U0UD6$)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. r z0Can't pass both `native_namespace` and `backend`z `backend` must be specified in `z`.)poprrry)rykwdsrrr%fnrAr@s rwrapper=deprecate_native_namespace..decorate..wrappershhy$/G#xx(:DA +j .cLI*!-'2EH o%!)go(8 RH o%%Ot$t$ $r)ryP.argsrFP.kwargsrro)r)rGrHrAr@s` rdecorate,deprecate_native_namespace..decorates% r % %  %*r)rGCallable[P, R]rrNrw)r@rArLs`` rdeprecate_native_namespacerOs2 Orc[U[SS9 [U[[S5SS9 US:a Sn[U5eUb)US:a Sn[U5eX:a Sn[ U5eX4$UnX4$)N window_size param_name min_samplesr[z+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_typerrrr7)rQrTr%s r_validate_rolling_argumentsrVs S]; S$t*GQ;o ??CS/ !  $JC', , %  ##"  ##rc [R"5RnUR 5R5n[SU55nUS-U::a[U[U55nSSU-S3nU[U5- nUSS US--US US-US---S 3- nUSS U-S 3- nXT- S-nXT- S-XT- S--n UH$n USS U-U S X-[U 5- -S 3- nM& US SU-S 3- nU$S[U5- n SSSS U S--US U S-U S---SSS 3 $![a$ [ [R "SS55nGN;f=f)NCOLUMNSPc38# UHn[U5v M g7fr)rw)rlines rr generate_repr..s>3t99r^u┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorrgetenv expandtabs splitlinesmaxrw) header native_reprterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrar[diffs r generate_reprrts7--/77))+668L>>>!~-%s6{3uv~&e,F + Ac\Q./0 PQ@QT`cdTd@d9e8ffijjAcVn%S))0Q6 .148QUV7VV  D #-.tfSI.s#L9KaS1#V,9Kr]z"Expected unique column names, got:)rwr collectionsrzrjoinr6)rrzrr|r duplicatesr%s rcheck_column_names_are_uniquers 7|s3w<((''"'.}}@tq!a%dad @ggL9I9I9KLL23%8S!!)As  BBcUc1SkO"[U[5(aU1O [U5nUcS1OF[U[[45(a [U51OUVs1sHo3b [U5OSiM snnX$4$s snf)N>smsnsus)rrurr ) time_unit time_zone time_unitstz time_zoness r_parse_time_unit_and_time_zoners    i % %[ ^     i#x 1 1)n T$rrw)_framers rrG$passthrough_column_names..fnFs r)rrrrrw)rrGs` rpassthrough_column_namesrEs Irc2[5n[XU5UL$r)objectr)rattrsentinels r_hasattr_staticrLsxH #X .h >>rc[US5$)N__narwhals_dataframe__rr#s ris_compliant_dataframerQs 3 8 99rc[US5$)N__narwhals_lazyframe__rr#s ris_compliant_lazyframer\s 3 8 99rc[US5$)N__narwhals_series__rr#s rr*r*bs 3 5 66rcZ[U5=(a URR5$r)r*r is_integerr#s rr'r'hs! s # > (<(<(>>rc[US5$)N__narwhals_expr__hasattrr#s ris_compliant_exprrns 3+ ,,rcU[R[R[R[R[R 1;$r)rrrrr rr#s ris_eager_allowedrtsA   rc[US5$)Nrrr#s rhas_native_namespacer~s 3 6 77rc[US5$)N __dataframe__rr#s r_supports_dataframe_interchangers 3 ((rc[US5$)N__arrow_c_stream__rr#s rsupports_arrow_c_streamrs 3 4 55rcH^^UU4SjU5n[[X55$)a+Remap 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. c3>># UHoT;aUT3OUv M g7frrw)rkeyleft_onsuffixs rr(_remap_full_join_keys..s&?G7N3%x3xs)dictzip)rright_onrright_keys_suffixeds` ` r_remap_full_join_keysrs% ?G H2 33rc[S5(aRURRRS5RnUR R XS9R$S[U5<S3n[U5e)zGuards `ArrowDataFrame.from_arrow` w/ safer imports. Arguments: data: Object which implements `__arrow_c_stream__`. context: Initialized compliant object. Returns: A PyArrow Table. r)contextzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type r) rrrrr _dataframe from_arrowrrModuleNotFoundError)datarrr%s r_into_arrow_tablersq    ' ' 4 4Y ? I I}}'''9@@@RSfgkSlRoopq!#&&rcU$)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) rw)rGs runstablers ( Irc8^[U4SjS55(+$)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,># UH oT;v M g7frrw)rxformats rr#_is_naive_format..s:(91;(9s)z%sz%zZ)any)rs`r_is_naive_formatrs:(9:: ::rcr\rSrSrSrS S SjjrS SjrSSjrS SSjjrSSjr \ SS j5r S r g)not_implementediaJMark 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 NcXlgr)_alias)raliass r__init__not_implemented.__init__s #( rcfS[U5RSURSUR3$)N: r)rry _name_owner_namers r__repr__not_implemented.__repr__s14:&&'s4+;+;*>> 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_versionru_hintc@URU5nXlX#lU$)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)rminimumhintrs rrUrequires.backend_versionUs"kk#"  rc2SRSU55$)Nrc3&# UHov M g7frrw)rds rr,requires._unparse_version..gs81#s)rrTs r_unparse_versionrequires._unparse_versionesxx8888rc NURUR:agURnURnUR UR5nUR UR5nSUSUSUSU<S3 nUR (aUSUR 3n[ U5e)N`z` is only available in 'z>=z', found version r )rr _wrapped_namerrrr)rrmethodrrfoundr%s r_ensure_versionrequires._ensure_versionis  $ $(9(9 9 ##**''(9(9:%%h&?&?@&1'"WIEVW\V__`a ::EDJJ<(C!#&&rcZ^^TRTl[T5SUU4Sjj5nU$)Nc>>TRU5 T"U/UQ70UD6$r)r )rryrFrGrs rrH"requires.__call__..wrapperxs&   *h... .r)rrryrJrFrKrro)ryr r)rrGrHs`` rrrequires.__call__us,[[ r /  / r)r N)r)rrurrrr=)rUrrru)rrrr)rG_Method[_ContextT, P, R]rr) ryrzr{r|rr}rZrU staticmethodrr rr~rwrrrr;sD,"! J  99 ' rrcURbURUR5OSnURbURUR5S-OSnURnX#U4$)Nr[)rrrr) str_slicerrrrs rconvert_str_slice_to_int_slicersX/8oo.IGMM)// *tE090J7== (1 ,PTD >>D  rc^SU4SjjnU$)zSteal the class-level docstring from parent and attach to child `__init__`. Returns: Decorated constructor. Notes: - Passes static typing (mostly) - Passes at runtime c>URS:Xa0[[T5[5(a[T5UlU$S[ RSUR <ST<3n[U5e)Nrz`@zL` is only allowed to decorate an `__init__` with a class-level doc. Method: z Parent: )ryrrrr inherit_docr{r) init_childr% tp_parents rrLinherit_doc..decoratesu   * ,DOT1R1R!' !2J  [))*+%2256$-)  C. r)r_Constructor[_T, P, R2]rrrw)rrLs` rrrs ! Orc[U[5(aUO [U5nURS:wa UROSnUSUR3R S5$)Nbuiltinsrr)rrrzrylstrip)rr6modules rrrsO3%%49B mmz9R]]rFXQr{{m $ + +C 00rrRcR[X5(dSRSU55nSU<S[U5<3nU(aZSn[U5n[ U5S:a[U5S3nUUS3nS [ U5-S [ U5--nUS UUS U3n[ U5eg ) amValidate 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 | c38# UHn[U5v M g7fr)r)rr6s rrensure_type..sL "1"55 r]z Expected z, got: z (z(...)=r_^r N)rrrreprrwr) rrS valid_typestp_namesr%left_padvalassign underlines rrUrUsB c ' '::L LL(W-@-E,HI Hs)C3x"},S12%8 z*Q/Fs6{*sSX~>IEF8C59+6Cn (rc6\rSrSrSrSSjrS SjrS SjrSrg) _DeferredIterableizLStore a callable producing an iterable to defer collection until we need it.cXlgr _into_iter)r into_iters rr_DeferredIterable.__init__s6?rc#@# UR5ShvN gN7frr3rs r__iter___DeferredIterable.__iter__s??$$$s cfUR5n[U[5(aU$[U5$r)r4rr|)rits rto_tuple_DeferredIterable.to_tuples) __ E**r9b 9rr3N)r5zCallable[[], Iterable[_T]]rr)rz Iterator[_T])rztuple[_T, ...]) ryrzr{r|rrr8r<r~rwrrr1r1sV@%:rr1)r&rurr9)rprrr)ryrrz list[Any])r}rrr)r}zAny | Iterable[Any]rrY)rsz#str | ModuleType | _SupportsVersionrr)rrrrrzTypeIs[type[_T]])r object | typerrrzTypeIs[_T | type[_T]])rrrtuple[type[_T1], type[_T2]]rzTypeIs[type[_T1 | _T2]])rr>rr?rz#TypeIs[_T1 | _T2 | type[_T1 | _T2]])rrr&tuple[type[_T1], type[_T2], type[_T3]]rzTypeIs[type[_T1 | _T2 | _T3]])rr>rr@rz/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]])rrr1tuple[type[_T1], type[_T2], type[_T3], type[_T4]]rz#TypeIs[type[_T1 | _T2 | _T3 | _T4]])rr>rrArz;TypeIs[_T1 | _T2 | _T3 | _T4 | type[_T1 | _T2 | _T3 | _T4]])rrrrrBrzGTypeIs[_T1 | _T2 | _T3 | _T4 | _T5 | type[_T1 | _T2 | _T3 | _T4 | _T5]])rrrGtuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5], type[_T6]]rz/TypeIs[type[_T1 | _T2 | _T3 | _T4 | _T5 | _T6]])rr>rrCrzSTypeIs[_T1 | _T2 | _T3 | _T4 | _T5 | _T6 | type[_T1 | _T2 | _T3 | _T4 | _T5 | _T6]])rrrRtuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5], type[_T6], type[_T7]]rz5TypeIs[type[_T1 | _T2 | _T3 | _T4 | _T5 | _T6 | _T7]])rr>rrDrz_TypeIs[_T1 | _T2 | _T3 | _T4 | _T5 | _T6 | _T7 | type[_T1 | _T2 | _T3 | _T4 | _T5 | _T6 | _T7]])rrrztuple[type, ...]rz TypeIs[Any])rrrrrrY)rz Iterable[Any]rr)rrdrz-Series[Any] | DataFrame[Any] | LazyFrame[Any]rrd)rz-DataFrame[Any] | LazyFrame[Any] | Series[Any]rrr)rrdrzstr | list[str] | Nonerz6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonerrd)rrdrrd)rrrrrzTypeIs[pd.RangeIndex])rzpd.Series[Any] | pd.DataFramerrrrY)rrdryrYrz bool | strrrd)rrrr]rz int | float)rz Series[Any]rrY)r rrContainer[str]rru)rrrz Iterable[str]rrYrz list[str])rSequence[_T] | AnyrTypeIs[Sequence[_T]])rrrzTypeIs[_SliceNone])rrrzCTypeIs[SizedMultiIndexSelector[Series[Any] | CompliantSeries[Any]]])rrFrz-TypeIs[Sequence[_T] | Series[Any] | _1DArray])rrrzTypeIs[_SliceIndex])rrrz TypeIs[range])rrrzTypeIs[SingleIndexSelector])rrrzTTypeIs[SingleIndexSelector | MultiIndexSelector[Series[Any] | CompliantSeries[Any]]])rrr6rrzTypeIs[list[_T]])rrr6rrrG)r bool | NonerrHr>rYrrY)r@rurArYrz*Callable[[Callable[P, R]], Callable[P, R]])rQrrTz int | Nonerztuple[int, int])rirurjrurru)rCollection[str]rrIrzColumnNotFoundError | None)rrIrr)rz$TimeUnit | Iterable[TimeUnit] | Nonerz7str | timezone | Iterable[str | timezone | None] | Nonerz%tuple[Set[TimeUnit], Set[str | None]]) rrQrrXrz Set[TimeUnit]rzSet[str | None]rrY)rrrr)rrrrErr)rrrzEvalNames[Any])rrrrurrY)rz[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co] | Anyrz]TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co, ToNarwhalsT_co]])rzICompliantLazyFrame[CompliantExprT, NativeFrameT_co, ToNarwhalsT_co] | AnyrzKTypeIs[CompliantLazyFrame[CompliantExprT, NativeFrameT_co, ToNarwhalsT_co]])rz'CompliantSeries[NativeSeriesT_co] | Anyrz)TypeIs[CompliantSeries[NativeSeriesT_co]])rzECompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co] | AnyrzGTypeIs[CompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co]])rrrz"TypeIs[EagerAllowedImplementation])rrrzTypeIs[SupportsNativeNamespace])rrrzTypeIs[DataFrameLike])rrrzTypeIs[ArrowStreamExportable])rrIrrIrrurzdict[str, str])rrKrrrzpa.Table)rGrmrrm)rrurrY)rrurrurr)rrbrrrz"tuple[int | None, int | None, Any])rzCallable[P, R1]rzr?narwhals._compliantr@rArBrCrDrErFnarwhals._compliant.typingrGrrHrInarwhals._translaterJrKrLrrNrOrrQrrSnarwhals.typingrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrfrgrhrirjrkrlrmrnrorprqrsrrrrrrrr}rrrrrrrrrrrrrrrr rr r r r rrgr#r$rUrzr~rxrorrrrrrrrrrrr r rr r$r(r+r-r0r2r4r7r<r?rOrVrtrrrrrrrrrrr*r'rrrrrrrrrrrrrrrrUr1rwrrr_s " XX--$*   &:<*[Z# 5IYY7%&&ininfSk&Q RN %.C %.C %.C %.C %.C %.C %.C %3 4C#A A B B8RxR00  T] \T 2 48 K~ 6 ==< i<  HZ(    x .   H -X- JHJ +^X(/8 42H 4IdIXC%ZC%N 9)EF""F:4Z : 6 ).M""$9 @ < D 2&&>Q S*L" $,     -5     ""$?"" "  ..-H.(. .  (($J("( (  ::-S:4: :  ..$U.(. .  FFCFAF F  44N4/4 4  RRNRMR R  ::Y:5: :  Y  @@@ ; @ @    " #3  \ \K\\~!L,0WEI W W(W B W  Wt/d8 9 MP   2 2 $20:22j2BJL L)LL$&N #0@DL9   H  2"D YJ     &&&)-&/&R$$#-$$0< .=""3"F"+"*     .; IX   M? : :  :: R:P: 7 07.7 ? 0?.? - N-L- 8)64 4(74AD44,'(.;$R(R(j#CCL$1'A81 IK,,^ : :r