:j UddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZmZddlmZmZmZddlmZddlmZmZdd lmZdd lmZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEddlFmGZGmHZHmIZIe"rYddlmJZJddlKmLZLddl!mMZMmNZNddlOZPddlQZRddlSZTddlUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]ddl^m_Z_ddl`maZambZbmcZcmdZdddlemfZfddlgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsddltmuZumvZvmwZwddlxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZmZmZmZmZmZmZmZmZddlmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZeZd!ed"<e(d#ee#ee#zee#z$Ze(d%Ze(d&Ze(d'Ze(d(d)$ZeWd*Ze(d+Ze(d,Ze(d-ZGd.d/e'ZGd0d1e'ZGd2d3e'Ze(d4Ze(d5d67Ze(d8d67Zd9Zd!ed:<e(d;e$ZdZd!ed?<Gd@dAe'eZGdBdCe'eZGdDdEe'ZGdFdGe'ZGdHdIe'ZGdJdKeee'ZGdLdMeee'ZGdNdOee'ZGdPdQeZGdRdSe,ZddTZeÐjdUeÐjdVeÐjdWeÐjdXeÐjdYeÐjdYeÐjdZeÐjd[eÐjd\eÐjd]eÐjd^i Zd_ed`<eÐjdaeÐjdbeÐjdceÐjddiZdeedf< edghddiZeddjZddkZddlZddmZddnZddoZe* ddpZe* ddqZe* ddrZe* ddsZe* ddtZe* dduZe* ddvZddwZddxZ ddyZddzZ ddd{ dd|Zdd}Zdd~Z ddZ ddZddZddZ d ddZ d ddZ ddZddZddZ ddZ ddZddZddZddZ ddZ ddZddZ ddZddZddZ ddZddd ddZ ddZddZ ddZddZ ddZ ddZddZddZddZeZded<ddZ ddZ ddZ ddZ ddZ ddZd dZd dZd dZ d dZ d dZ ddZ ddZ ddZddZddZGddZddZGddZ ddZ ddZddZddddZGdde%eZedhddZddZGd„deeee'eZGdĄde'eZGdƄdǫZddȄZej>dk7rddʄZ ndd˄Z dd̄Z!Gd̈́deZ"e"jFZ$e$Z#e%dZ&y() annotationsN)Callable Collection ContainerIterableIteratorMappingSequence)timezone)Enumauto)cache lru_cachewraps) find_spec)getattr_staticgetdoc) attrgetter)Path) token_hex) TYPE_CHECKINGAnyFinalGenericLiteralProtocolTypeVarcastoverload) 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 TypeAlias) LiteralString ParamSpecSelfTypeIs)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 IntoSeriesTMultiIndexSelector NestedLiteralSingleIndexSelectorSizedMultiBoolSelectorSizedMultiIndexSelectorSizeUnitSupportsNativeNamespaceTimeUnit_1DArray _SliceIndex _SliceName _SliceNoner=UnknownBackendNameFrameOrSeriesT)bound_T1_T2_T3_FnzCallable[..., Any]PRR1R2ceZdZUded<y)_SupportsVersionstr __version__N__name__ __module__ __qualname____annotations__d/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/narwhals/_utils.pyrrsrrceZdZdddZy) _SupportsGetNcyNrselfinstanceowners r__get__z_SupportsGet.__get__srr)rrr Any | Nonereturnr)rrrrrrrrrsQrrceZdZeddZy)_StoresColumnscyrrrs rcolumnsz_StoresColumns.columnss,/rN)r Sequence[str])rrrpropertyrrrrrrs / /rr_T NativeT_coT) covariant CompliantT_coz._FullContext | NamespaceAccessor[_FullContext] _IntoContext _IntoContextTz*Callable[Concatenate[_IntoContextT, P], R]_Methodz Callable[Concatenate[_T, P], R2] _Constructorc"eZdZdZeddZy) _StoresNativezProvides access to a native object. Native objects have types like: >>> from pandas import Series >>> from pyarrow import Table cy)zReturn the native object.Nrrs rnativez_StoresNative.native rN)rr)rrr__doc__rrrrrrr  rrc"eZdZdZeddZy)_StoresCompliantzProvides access to a compliant object. Compliant objects have types like: >>> from narwhals._pandas_like.series import PandasLikeSeries >>> from narwhals._arrow.dataframe import ArrowDataFrame cy)zReturn the compliant object.Nrrs r compliantz_StoresCompliant.compliantrrN)rr)rrrrrrrrrrrrrrceZdZeddZy)_StoresBackendVersioncy)z#Version tuple for a native package.Nrrs r_backend_versionz&_StoresBackendVersion._backend_versionrrNrtuple[int, ...])rrrrrrrrrrs   rrceZdZUded<y)_StoresVersionVersion_versionNrrrrrrs ,rrceZdZUded<y)_StoresImplementationImplementation_implementationNrrrrrrs ##IrrceZdZdZy)_LimitedContextzEProvides 2 attributes. - `_implementation` - `_version` NrrrrrrrrrrrceZdZdZy) _FullContextzMProvides 2 attributes. - `_implementation` - `_backend_version` NrrrrrrrrrceZdZdZddZy)ValidateBackendVersionz=Ensure the target `Implementation` is on a supported version.c8|jj}y)zRaise if installed version below `nw._utils.MIN_VERSIONS`. **Only use this when moving between backends.** Otherwise, the validation will have taken place already. N)rr)r_s r_validate_backend_versionz0ValidateBackendVersion._validate_backend_versions  1 1 3rN)rNone)rrrrrrrrrrs G4rrceZdZeZeZeZeddZeddZ ed dZ ed dZ ed dZ y) rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)NrrJ)rV1narwhals.stable.v1._namespacerKV2narwhals.stable.v2._namespacenarwhals._namespace)r NamespaceV1 NamespaceV2rKs r namespacezVersion.namespaces5 7::  N  7::  N 1rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)dtypes)rrnarwhals.stable.v1rrnarwhals.stable.v2narwhals)r dtypes_v1 dtypes_v2rs rrzVersion.dtypes s4 7::  >  7::  > # rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)rm)rrrrmrrnarwhals.dataframe)r DataFrameV1 DataFrameV2rms r dataframezVersion.dataframe5 7::  C  7::  C 0rcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nr)rn)rrrrnrrr)r LazyFrameV1 LazyFrameV2rns r lazyframezVersion.lazyframe'rrcz|tjurddlm}|S|tjurddlm}|Sddlm}|S)Nrrq)rrrrrrrnarwhals.series)rSeriesV1SeriesV2rrs rserieszVersion.series5s2 7::  =O 7::  =O* rN)rztype[Namespace[Any]])rrv)rztype[DataFrame[Any]])rztype[LazyFrame[Any]])rztype[Series[Any]]) rrrr rrMAINrrrrrrrrrrrsy B B 6D           rrc&eZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z d"dZe d#dZed$dZe d%dZd&dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZd'dZ d'dZ!d'dZ"d(d Z#y!))rz?Implementation of native object (pandas, Polars, PyArrow, ...).pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframezpyspark[connect]unknownc,t|jSr)rvaluers r__str__zImplementation.__str__`s4::rcVttjttjt tj ttjttjttjttjttj t#tj$t'tj(t+tj,i }|j/|tj0S)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. )r)rPANDASr(MODINr$CUDFr+PYARROWr-PYSPARKr*POLARSr%DASKr&DUCKDBr'IBISr.SQLFRAMEr,PYSPARK_CONNECTgetUNKNOWN)clsnative_namespacemappings rfrom_native_namespacez$Implementation.from_native_namespacecs L.// K-- J++ M>11  ~55 L.//  ."5"5 L.// J++ NN33  !>#A#A  {{+^-C-CDDrcR ||S#t$rtjcYSwxYw)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. ) ValueErrorrr)r backend_names r from_stringzImplementation.from_string{s- *|$ $ *!)) ) *s  &&ct|tr|j|St|tr|S|j |S)zInstantiate from native namespace module, string, or Implementation. Arguments: backend: Backend to instantiate Implementation from. ) isinstancerr rr)rbackends r from_backendzImplementation.from_backendsL'3' OOG $ '>2 **73  rc|tjur d}t||jtj ||j }t|S)zCReturn the native namespace module corresponding to Implementation.z:Cannot return native namespace from UNKNOWN Implementation)rrAssertionErrorr_IMPLEMENTATION_TO_MODULE_NAMErr _import_native_namespace)rmsg module_names rto_native_namespacez"Implementation.to_native_namespacesM >)) )NC % % 488tzzJ ' 44rc&|tjuS)a7Return whether implementation is pandas. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas() True )rr rs r is_pandaszImplementation.is_pandas~,,,,rcd|tjtjtjhvS)aLReturn whether implementation is pandas, Modin, or cuDF. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas_like() True )rr r rrs ris_pandas_likezImplementation.is_pandas_likes(--~/C/C^EXEXYYYrcd|tjtjtjhvS)aIReturn whether implementation is pyspark or sqlframe. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_spark_like() False )rrrrrs r is_spark_likezImplementation.is_spark_likes1  " "  # #  * *   rc&|tjuS)a7Return whether implementation is Polars. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_polars() True )rrrs r is_polarszImplementation.is_polarsr.rc&|tjuS)a4Return whether implementation is cuDF. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_cudf() False )rrrs ris_cudfzImplementation.is_cudf~****rc&|tjuS)a6Return whether implementation is Modin. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_modin() False )rr rs ris_modinzImplementation.is_modins~++++rc&|tjuS)a:Return whether implementation is PySpark. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark() False )rrrs r is_pysparkzImplementation.is_pyspark~----rc&|tjuS)aBReturn whether implementation is PySpark. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark_connect() False )rrrs ris_pyspark_connectz!Implementation.is_pyspark_connects~5555rc&|tjuS)a:Return whether implementation is PyArrow. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyarrow() False )rrrs r is_pyarrowzImplementation.is_pyarrowr<rc&|tjuS)a4Return whether implementation is Dask. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_dask() False )rrrs ris_daskzImplementation.is_daskr7rc&|tjuS)a8Return whether implementation is DuckDB. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_duckdb() False )rrrs r is_duckdbzImplementation.is_duckdb(r.rc&|tjuS)a4Return whether implementation is Ibis. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_ibis() False )rrrs ris_ibiszImplementation.is_ibis5r7rc&|tjuS)a<Return whether implementation is SQLFrame. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_sqlframe() False )rrrs r is_sqlframezImplementation.is_sqlframeBs~....rct|S)zReturns backend version.backend_versionrs rrzImplementation._backend_versionOs t$$rNrr)r type[Self]rr;rr)rrMrrrr)rrMr#z)IntoBackend[Backend] | UnknownBackendNamerr)rr;)rboolr)$rrrrr r rrrrrrrrrrr  classmethodrr r$r+r-r0r2r4r6r9r;r>r@rBrDrFrHrrrrrrDs'I F E DG!G! F D F DH"(O)G!E E+5E EE. * *  "K   5 - Z " - + , . 6 . + - + /%rrcp|jxs|jxr|jdkS)zJWhether implementation is PySpark (or PySpark Connect) with version < 4.0.)r)r;r>rimplementations ris_pyspark_pre_4rTTs9 !!#J~'H'H'J 5  ) ) +f 45r)rQ)rr) ) )rV)rrQ)i)rUrU))rVrWrz(Mapping[Implementation, tuple[int, ...]] MIN_VERSIONSzdask.dataframez modin.pandasz pyspark.sqlzpyspark.sql.connectzMapping[Implementation, str]r')maxsizecddlm}||S)Nr) import_module) importlibrc)r*rcs rr(r(rs'  %%rct|ts t||tjury|}tj ||j }t|}|jrddl }|j}n@|js|jrddl }|}n|jrddl}|}n|}t!|}|t"|x} krd|d| d|} t%| |S)N)rrrrzMinimum version of z supported by Narwhals is z , found: )r"rr"rr'rr r(rHsqlframe._versionrr;r>rrBr parse_versionr_r) rSimplr*rr into_versionrrversion min_versionr)s rrKrK|s nn 5^$/// D044T4::FK/ <  ((  d557  ' L)Gd!33+4#D6)CK=PYZaYbco Nrcbtt|dk(rt|dr |dS|S)NrUr)listlen _is_iterable)argss rflattenrqs. CIN|DG/DQ PP4 PPrc8t|ttfs|fS|Sr)r"rmtuple)args rtupleifyrus cD%= )v Jrczddlm}tx}"t||j|jfsDt x}Rt||j|j |j|jfrdt|d}t|t|txrt|tt|f S)Nrrqz(Expected Narwhals class or scalar, got: z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?) rrrr)r"rmr*Exprrnqualified_type_name TypeErrorrrbytes)rtrrpdplr)s rroros&| (Zbii=V-W| ( sRYYr||L M77J37O6RS3 3 n c8 $ RZc5&=Q-R)RRrc"t|tSr)r"r)vals r is_iteratorrs c8 $$rct|tr|n |j}tjdd|}t d|j dDS)zSimple version parser; split into a tuple of ints for comparison. Arguments: version: Version string, or object with one, to parse. z (\D?dev.*$)c3\K|]$}ttjdd|&yw)z\DrN)intresub).0vs r z parse_version..s"KqRVVE2q)*Ks*,.)r"rrrrrssplit)rj version_strs rrgrgsH(5'7;N;NK&&[9K KK4E4Ec4JK KKrcyrr obj_or_cls cls_or_tuples risinstance_or_issubclassrsrcyrrrs rrr rcyrrrs rrrs"rcyrrrs rrrs+.rcyrrrs rrrs%(rcyrrrs rrrs7:rcyrrrs rrrsrcddlm}t||r t||St||xst|txr t ||S)Nrro)narwhals.dtypesrpr"type issubclass)rrrps rrrsF%*e$*l33 j, / :t$MJ )Mrcddlmmtfd|Dstfd|Dryd|Dcgc] }t |c}}t |cc}w)Nrrlc36K|]}t|ywrr")ritemrms rrz$validate_laziness..s 94:dI & 9c36K|]}t|ywrr)rrrns rrz$validate_laziness..s :DJtY ' :rzGThe items to concatenate should either all be eager, or all lazy, got: )rrmrnallrry)itemsrr)rmrns @@rvalidate_lazinessrsW7 95 99 :E :: SlqTrdhUYZ^U_TrSs tC C.UssAcddlm}ddlm}d d}t d|}t d|}t t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt t |dd|rt t |dd|r||jjj||jjj|j|jj|jjj|jjjSt|t|k7r%d t|d t|}t||S) aAlign `lhs` to the Index of `rhs`, if they're both pandas-like. Arguments: lhs: Dataframe or Series. rhs: Dataframe or Series to align with. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this only checks that `lhs` and `rhs` are the same length. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2]}, index=[3, 4]) >>> s_pd = pd.Series([6, 7], index=[4, 3]) >>> df = nw.from_native(df_pd) >>> s = nw.from_native(s_pd, series_only=True) >>> nw.to_native(nw.maybe_align_index(df, s)) a 4 2 3 1 r)PandasLikeDataFrame)PandasLikeSeriesrc6|js d}t|y)Nz'given index doesn't have a unique index) is_uniquer)indexr)s r_validate_indexz*maybe_align_index.._validate_index,s;CS/ !r_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrrr)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrrr"getattrrrr_with_compliant _with_nativelocrrnr)lhsrhsrrrlhs_anyrhs_anyr)s rmaybe_align_indexr sI<D=" 5#G5#G+T24G WW&8$?AT U0077==>0077==>&&  $ $ 1 1((//33G4L4L4S4S4Y4YZ   +T24G WW&94@BR S0077==>1188>>?&&  $ $ 1 1((//33--44::   ,d35E WW&8$?AT U1188>>?0077==>&&  % % 2 2))0044,,3399   ,d35E WW&94@BR S1188>>?1188>>?&&  % % 2 2))0044--44::    7|s7|#Fs7|nTYZ]^eZfYgho Jrctd|}|j}t|s t|r |jSy)aGet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. 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_nativer5r6r)objobj_any native_objs rmaybe_get_indexrgs=45#G""$J +/DZ/P r)rcVddlm}td|}|j}|| d}t||s| d}t||.t |r|Dcgc] }||dc}n ||d}n|}t |r9|j |jj|j|St|r^ddl m } |r d }t|| |||jj }|j |jj|S|Scc}w) aSet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: object for which maybe set the index (can be either a Narwhals `DataFrame` or `Series`). column_names: name or list of names of the columns to set as index. For dataframes, only one of `column_names` and `index` can be specified but not both. If `column_names` is passed and `df` is a Series, then a `ValueError` is raised. index: series or list of series to set as index. 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 SeriesrR)narwhals.translaterrrror5rrrrr6narwhals._pandas_like.utilsrr) r column_namesrrdf_anyrr)idxkeysrs rmaybe_set_indexrs7X- % F!!#JE$5Ho EMCo E";@ @3Ys . @5t4  +%%  # # 0 01E1Ed1K L  Z(9 CCS/ !  00@@ %%f&>&>&K&KJ&WXX M1 AsD&ctd|}|j}t|rX|j}t ||r|S|j |j j|jdSt|rX|j}t ||r|S|j |jj|jdS|S)aReset the index to the default integer index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. 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) rrr5__native_namespace___has_default_indexrrr reset_indexr6r)rrrrs rmaybe_reset_indexrs85#G""$J +"779 j*: ;N&&  $ $ 1 1*2H2Hd2H2S T  Z("779 j*: ;N&&  % % 2 2:3I3It3I3T U   Nrc.t||jSr)r" RangeIndex)rrs r_is_range_indexr s c+66 77rc|j}t||xr:|jdk(xr)|jt |k(xr|j dk(S)NrrU)rrstartstoprnstep)native_frame_or_seriesrrs rrrsW # ( (E/0  KK1   JJ#e* $  JJ!O rc |jjs|S|j|jj |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)rSr0r _compliantrrconvert_dtypesr)rrpkwargsresults rmaybe_convert_dtypesrsgB    , , .   ##$BCMMO$B$BD$SF$STF  & ))rcv|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 >brz>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got r)szunitr)s r scale_bytesrFss ~  ""Dy ""G| ""G| ""G| Gx PC S/rcddlm}|jjj}|j}d}t ||r;t |j |jr|jjd}|S|j |jk(rd}|S|j |jk7rd}|S|j}|j}|jr8|jdkr%td|j j dk(}|S|j#r!t%|j&j(}|S|j+r0dd lm}||j0xr|j0j(}|S) aReturn whether indices of categories are semantically meaningful. This is a convenience function to accessing what would otherwise be the `is_ordered` property from the DataFrame Interchange Protocol, see https://data-apis.org/dataframe-protocol/latest/API.html. - For Polars: - Enums are always ordered. - Categoricals are ordered if `dtype.ordering == "physical"`. - For pandas-like APIs: - Categoricals are ordered if `dtype.cat.ordered == True`. - For PyArrow table: - Categoricals are ordered if `dtype.type.ordered == True`. Arguments: series: Input Series. 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)rU zpl.Categoricalphysical) is_dictionary)narwhals._interchange.seriesrrrrr"dtype Categoricalrdescribe_categoricalr rrSr4rrorderingr0rNcatorderedr@narwhals._arrow.utilsrr)rrrrrrrhrs ris_ordered_categoricalr[saF?  % % . . 5 5F((IF)./J f((5!!66|D& M%  $" M! ++ + M!!#$$ >>  5 5 7' A*FLL9BBjPF M  "&**,,-F M __  ;"6;;/GFKK4G4GF Mrc<d}t|dt|||S)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versionsz1.13.0r)n_bytesrprefix)r!generate_temporary_column_name)rrrr)s rgenerate_unique_tokenrs( ?cH5 )'7SY ZZrctd} |t|dz x}|vr|S|dz }|dkDrd|d|}t|6)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 rrUdzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr&)rrrcountertokenr)s rrrsm<G x 'A+ 678 8E HL1  S=*L 3 !% % rc|s-tt|jj|St|}t ||jx}r||S)N) available)rmsetr intersectioncheck_columns_exist)framesubsetstrictto_droperrors rparse_columns_to_droprsO C &33F;<<6lG#Gu}}EEuE NrcHt|txrt|t Sr)r"r r)sequences ris_sequence_but_not_strrs h ) K*Xs2K.KKrcBt|txr|tdk(Sr)r"slicers r is_slice_noners c5 ! 8cU4[&88rct|xr.t|dkDxrt|dxst|dk(xs%t|xst |xs t |SNr)rrnis_single_index_selectorr4r1is_compliant_series_intrs ris_sized_multi_index_selectorrsl $C ( Yc(Q,C#;CF#CWSUV ( ! %  ( "# &  ( #3 'rcft|xs%t|xst|xs t|Sr)rr2r/is_compliant_seriesrs ris_sequence_likers: $ $ S ! $ c " $ s # rct|txrxt|jtxs\t|jtxs@t|j tt fxr|jduxr|jduSr)r"rrrrrNoneTypers ris_slice_indexr sr c5 ! 399c" chh $  sxx#x 1 ! T! !D rc"t|tSr)r"rangers ris_ranger# s c5 !!rcZtt|txrt|t Sr)rNr"rrs rrrs#  3$BZT-B)B CCrcLt|xst|xs t|Sr)rrr rs ris_index_selectorr&s+ !%  ( -  # rct|xr#t|dkDxrt|dtxs%t |xst |xs t |Sr)rrnr"rNr3r0is_compliant_series_boolrs ris_boolean_selectorr)sW ! % U3s8a<+TJs1vt.1s=$z$%=sany) predicatess r predicates_contains_list_of_boolr3.s =*= ==rcxtt|xr%tt|dx}xr t ||Sr)rNrnextiterr")rr+firsts ris_sequence_ofr84s> $ "49d+ +U " ub ! rc8t|tttfSr)r"rmrsdictrs ris_nested_literalr;=s cD%. //rcL|||}|S||| }|S|| |Sd}t|)Nz,Cannot pass both `strict` and `pass_through`r)r rpass_through_defaultr)s rvalidate_strict_and_pass_thoughr>As_ ~,.+     4!z  L4  =orrF) warn_versionrequiredcdfd }|S)a8Decorator to transition from `native_namespace` to `backend` argument. Arguments: warn_version: Emit a deprecation warning from this version. required: Raise when both `native_namespace`, `backend` are `None`. Returns: Wrapped function, with `native_namespace` **removed**. c6tdfd }|S)Nc|jdd}|jdd}||rd}t||}n2|| d}t|||rdjd}t|||d<|i|S)Nr#rz`native_namespace` is deprecated, please use `backend` instead. Note: `native_namespace` will remain available in `narwhals.stable.v1`. See https://narwhals-dev.github.io/narwhals/backcompat/ for more information. rz0Can't pass both `native_namespace` and `backend`z `backend` must be specified in `z`.)popr!rr)rpkwdsr#rr)fnr@r?s rwrapperz=deprecate_native_namespace..decorate..wrapperashhy$/G#xx(:DA +j .cLI*!-'2EH o%!)go(8 RH o%%DOt$t$ $r)rpP.argsrEP.kwargsrr)r)rFrGr@r?s` rdecoratez,deprecate_native_namespace..decorate`s r %  %*r)rFCallable[P, R]rrKr)r?r@rJs`` rdeprecate_native_namespacerLSs2 Orct|tdt|ttdd|dkr d}t||(|dkr d}t|||kDr d}t |||fS|}||fS)N window_size param_name min_samplesrUz+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_typerrrr9)rNrQr)s r_validate_rolling_argumentsrS|s S]; S$t*GQ;o ??CS/ !  $JC', ,  ##"  ##rc  tjj}|j j}td|D}|dz|krt|t|}dd|zd}|t|z }|dd |dzz|d |dz|dzzzd z }|dd |zd z }||z dz}||z dz||z dzz} |D]$} |dd |z| d | |zt| z zd z }&|d d|zd z }|Sdt|z } dddd | dzz|d | dz| dzzzddd S#t$r#t tj dd}Y:wxYw)NCOLUMNSPc32K|]}t|ywr)rn)rlines rrz generate_repr..s>3t9>u┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorrgetenv expandtabs splitlinesmaxrn) header native_reprterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrarXdiffs r generate_reprrqs7--/77))+668L>>>!~-%s6{3uv~&e,F + Ac\Q./0 PQ@QT`cdTd@d9e8ffijjAcVn%S)) 00Q6 ..14AQ8QUV7VV   kD #-.tfSIHX.s#LAaS1#V,Lsz"Expected unique column names, got:)rnr collectionsrwrjoinr8)rrwrryr duplicatesr)s rcheck_column_names_are_uniquer}s 7|s3w<((''"'.}}@tq!!a%ad@ @ggL9I9I9KLL23%8S!!)As  BBc|hdnt|tr|hn t|}|dhn>t|ttfr t|hn|Dchc]}| t|ndc}}||fScc}w)N>smsnsus)r"rrr ) time_unit time_zone time_unitstz time_zoness r_parse_time_unit_and_time_zoners    i %[ ^     i#x 1)n .fns r)rrrrr)rrFs` rpassthrough_column_namesrs Irr _SENTINELc0t||ttuSr)rr)rattrs r_hasattr_staticrs #tY /y @@rct|dS)N__narwhals_dataframe__rrs ris_compliant_dataframers 3 8 99rct|dS)N__narwhals_lazyframe__rrs ris_compliant_lazyframer s 3 8 99rct|dS)N__narwhals_series__rrs rrrs 3 5 66rcPt|xr|jjSr)rr is_integerrs rrr! s # > (<(<(>>rcPt|xr|jjSr)rr is_booleanrs rr(r(rrc6t|dxr t|dS)Nr _accessorrrs r_is_namespace_accessorr"s 3 , Rk1RRrc|tjtjtjtjtj hvS)z.Return True if `impl` allows eager operations.)rrr r rrrhs ris_eager_allowedr,sA   rcd|tjtjtjhvS)z4Return True if `LazyFrame.collect(impl)` is allowed.)rr rrrs rcan_lazyframe_collectr7s& N))>+@+@.BXBXY YYrc|tjtjtjtjtj tj tjhvS)z1Return True if `DataFrame.lazy(impl)` is allowed.)rrrrrrrrrs ris_lazy_allowedr<sS && rct|dS)Nrrrs rhas_native_namespacerIs 3 6 77rct|dS)N__arrow_c_stream__rrs rsupports_arrow_c_streamrMs 3 4 55rcLfd|D}tt||dS)aORemap join keys to avoid collisions. If left keys collide with the right keys, append the suffix. If there's no collision, let the right keys be. Arguments: left_on: Left keys. right_on: Right keys. suffix: Suffix to append to right keys. Returns: A map of old to new right keys. c36K|]}|vr|n|ywrr)rkeyleft_onsuffixs rrz(_remap_full_join_keys..as*8;C7N3%x3rF)r )r:zip)rright_onrright_keys_suffixeds` ` r_remap_full_join_keysrQs* ?G H1%@ AArctdrV|jjjdj}|j j ||jSdt|d}t|)zGuards `ArrowDataFrame.from_arrow` w/ safer imports. Arguments: data: Object which implements `__arrow_c_stream__`. context: Initialized compliant object. r)contextzB'pyarrow>=14.0.0' is required for `from_arrow` for object of type r) rrrr$r _dataframe from_arrowrrxModuleNotFoundError)datarrr)s r_into_arrow_tablergsp    ' ' 4 4Y ? I I}}''b'9@@@ NObcgOhNkkl mC c ""rc|S)aVisual-only marker for unstable functionality. Arguments: fn: Function to decorate. Returns: Decorated function (unchanged). Examples: >>> @unstable ... def a_work_in_progress_feature(*args): ... return args >>> >>> a_work_in_progress_feature.__name__ 'a_work_in_progress_feature' >>> a_work_in_progress_feature(1, 2, 3) (1, 2, 3) r)rFs runstablerws & Irc.tfddD S)aDetermines if a datetime format string is 'naive', i.e., does not include timezone information. A format is considered naive if it does not contain any of the following - '%s': Unix timestamp - '%z': UTC offset - 'Z' : UTC timezone designator Arguments: format: The datetime format string to check. Returns: bool: True if the format is naive (does not include timezone info), False otherwise. c3&K|]}|v ywrr)rxformats rrz#_is_naive_format..s:11;:s)z%sz%zZr0)rs`r_is_naive_formatrs:(9:: ::rcZeZdZdZd d dZd dZd dZ d d dZddZe ddZ y)not_implementedaMark some functionality as unsupported. Arguments: alias: optional name used instead of the data model hook [`__set_name__`]. Returns: An exception-raising [descriptor]. Notes: - Attribute/method name *doesn't* need to be declared twice - Allows different behavior when looked up on the class vs instance - Allows us to use `isinstance(...)` instead of monkeypatching an attribute to the function Examples: >>> class Thing: ... def totally_ready(self) -> str: ... return "I'm ready!" ... ... not_ready_yet = not_implemented() >>> >>> thing = Thing() >>> thing.totally_ready() "I'm ready!" >>> thing.not_ready_yet() Traceback (most recent call last): ... NotImplementedError: 'not_ready_yet' is not implemented for: 'Thing'. ... >>> isinstance(Thing.not_ready_yet, not_implemented) True [`__set_name__`]: https://docs.python.org/3/reference/datamodel.html#object.__set_name__ [descriptor]: https://docs.python.org/3/howto/descriptor.html Nc||_yr)_alias)raliass r__init__znot_implemented.__init__s #( rcfdt|jd|jd|jS)N: r)rr _name_owner_namers r__repr__znot_implemented.__repr__s14:&&'s4+;+;*T>TU !7!7 7~&C""C$TZZ5rc$|jdS)Nraise)r)rrprEs r__call__znot_implemented.__call__s||G$$rc2|}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#)rmessagers rr#znot_implemented.deprecatedse"z'"3''rr)rz str | NonerrrL)rtype[_T]rrrr)rz_T | Literal['raise'] | Nonerztype[_T] | Nonerr)rprrErrr)rr>rr@) rrrrrrrrrrOr#rrrrrsU!F( K. PT4=L $%  ( (rrc(|d|d}t|)Nz is not implemented for: z. If you would like to see this functionality in `narwhals`, please open an issue at: https://github.com/narwhals-dev/narwhals/issues)NotImplementedError)whatrr)s rrrs, (+C73S S c ""rceZdZUdZded<ded<ded< edddZeddZdd Z dd Z dd Z dd Z y )requiresaMethod decorator for raising under certain constraints. Attributes: _min_version: Minimum backend version. _hint: Optional suggested alternative. Examples: >>> 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_namecD|j|}||_||_|S)zMethod decorator for raising below a minimum `_backend_version`. Arguments: minimum: Minimum backend version. hint: Optional suggested alternative. )__new__rr)rminimumhintrs rrKzrequires.backend_versions&kk#"  rc2djd|DS)Nrc3"K|]}| ywrr)rds rrz,requires._unparse_version..*s811#8s )r{rJs r_unparse_versionzrequires._unparse_version(sxx8888rcNd|jvr|d|j|_yyNr)r)rrs r_qualify_accessor_namezrequires._qualify_accessor_name,s/ d(( ($*81T-?-?,@!AD  )rct|r(|j|j|j}n|}|jt |j fSr)rrrrrrr)rrrs r_unwrap_contextzrequires._unwrap_context1sJ !( +  ' '(:(: ; **I I))3y/H/H+IIIrc $|j|\}}||jk\ry|j|j}|j|}d|jd|d|d|d }|jr|d|j}t |)N`z` is only available in 'z>=z', found version r )rrrrrr)rrrjr#rfoundr)s r_ensure_versionzrequires._ensure_version9s//9 d'' ' ''(9(9:%%g.$$$%%=gYb Qbchbkklm ::EDJJ<(C!#&&rcVj_tdfd }|S)Nc>j||g|i|Sr)r)rrprErFrs rrGz"requires.__call__..wrapperIs&   *h... .r)rrrprHrErIrr)rrr)rrFrGs`` rrzrequires.__call__Ds. [[ r /  / rN)r)rrrrrr@)rKrrr)rrFrr)rrrztuple[tuple[int, ...], str])rrrr)rF_Method[_IntoContextT, P, R]rr) rrrrrrOrK staticmethodrrrrrrrrrrsm*"! J   99B J ' .  % rrc|j|j|jnd}|j|j|jdznd}|j}|||fS)NrU)rrrr) str_slicerrrrs rconvert_str_slice_to_int_slicer RsZ/8oo.IGMM)// *tE090J7== (1 ,PTD >>D 4 rcdfd }|S)zSteal the class-level docstring from parent and attach to child `__init__`. Returns: Decorated constructor. Notes: - Passes static typing (mostly) - Passes at runtime c|jdk(r+tttrt|_|Sdt jd|j d}t|)Nrz`@zL` is only allowed to decorate an `__init__` with a class-level doc. Method: z Parent: )rrrrr inherit_docrry) init_childr) tp_parents rrJzinherit_doc..decoratehsp   * ,DOT1R!' !2J  %%&'!..12 m % nr)r_Constructor[_T, P, R2]rrr)rrJs` rr r [s  Orct|tr|n t|}|jdk7r |jnd}|d|jj dS)Nbuiltinsrr)r"rrrlstrip)rr+modules rrxrxvsL3%49B mmz9R]]rFXQr{{m $ + +C 00rrOc:t||sdjd|D}d|dt|}|rYd}t|}t |dkDrt|d}||d}d t |zd t |zz}|d ||d |}t |y ) aValidate that an object is an instance of one or more specified types. Parameters: obj: The object to validate. *valid_types: One or more valid types that `obj` is expected to match. param_name: The name of the parameter being validated. Used to improve error message clarity. Raises: TypeError: If `obj` is not an instance of any of the provided `valid_types`. Examples: >>> 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.DataFrame', got: 'polars.dataframe.frame.DataFrame' df=polars.dataframe.frame.DataFrame(...) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ z | c32K|]}t|ywr)rx)rr+s rrzensure_type..sL"1"5LrYz Expected z, got: z (z(...)=r\^rN)r"r{rxrrnry) rrP valid_typestp_namesr)left_padr~assign underlines rrRrR|s@ c; '::L LL(W-@-E,HI Hs)C3x"},S12%8 z*Q/Fs6{*sSX~>IEF8C59+6Cn (rc(eZdZdZddZddZddZy) _DeferredIterablezLStore a callable producing an iterable to defer collection until we need it.c||_yr _into_iter)r into_iters rrz_DeferredIterable.__init__s 6?rc#@K|jEd{y7wrr"rs r__iter__z_DeferredIterable.__iter__s??$$$s c\|j}t|tr|St|Sr)r#r"rs)rits rto_tuplez_DeferredIterable.to_tuples& __ E*r9b 9rN)r$zCallable[[], Iterable[_T]]rr)rz Iterator[_T])rztuple[_T, ...])rrrrrr&r)rrrr r sV@%:rr @cJ|rdj|g|n|}t|Sr)r{r)rnestedrs rdeep_attrgetterr-s%(.388TOFO $DD d rc&t|g||S)z+Perform a nested attribute lookup on `obj`.)r-)rname_1r,s r deep_getattrr0s +?6 +F +C 00rc eZdZy) CompliantN)rrrrrrr2r2srr2c"eZdZdZeddZy)NarwhalsaMinimal *Narwhals-level* protocol. Provides access to a compliant object: obj: Narwhals[NativeT_co]] compliant: Compliant[NativeT_co] = obj._compliant Which itself exposes: implementation: Implementation = compliant.implementation native: NativeT_co = compliant.native This interface is used for revealing which `Implementation` member is associated with **either**: - One or more [nominal] native type(s) - One or more [structural] type(s) - where the true native type(s) are [assignable to] *at least* one of them These relationships are defined in the `@overload`s of `_Implementation.__get__(...)`. [nominal]: https://typing.python.org/en/latest/spec/glossary.html#term-nominal [structural]: https://typing.python.org/en/latest/spec/glossary.html#term-structural [assignable to]: https://typing.python.org/en/latest/spec/glossary.html#term-assignable cyrrrs rrzNarwhals._compliants36rN)rzCompliant[NativeT_co])rrrrrrrrrr4r4s066rr4cjeZdZdZddZeddZeddZeddZeddZe ddZeddZe dd Zedd Ze dd Zedd Zedd Ze d dZed!dZe d"dZed#dZd$dZy)%_ImplementationzDescriptor for matching an opaque `Implementation` on a generic class. Based on [pyright comment](https://github.com/microsoft/pyright/issues/3071#issuecomment-1043978070) c||_yr)rrs rrz_Implementation.__set_name__s ! rcyrrrs rrz_Implementation.__get__TWrcyrrrs rrz_Implementation.__get__r:rcyrrrs rrz_Implementation.__get__RUrcyrrrs rrz_Implementation.__get__PSrcyrrrs rrz_Implementation.__get__srcyrrrs rrz_Implementation.__get__r=rcyrrrs rrz_Implementation.__get__s25rcyrrrs rrz_Implementation.__get__r:rcyrrrs rrz_Implementation.__get__srcyrrrs rrz_Implementation.__get__r?rcyrrrs rrz_Implementation.__get__ r?rcyrrrs rrz_Implementation.__get__ s.1rcyrrrs rrz_Implementation.__get__sKNrcyrrrs rrz_Implementation.__get__rrcyrrrs rrz_Implementation.__get__sQTrc6||S|jjSr)rrrs rrz_Implementation.__get__s'tPX-@-@-P-PPrN)r type[Any]rrrr)rzNarwhals[NativePolars]rrrrh)rzNarwhals[NativePandas]rrrrf)rzNarwhals[NativeModin]rrrre)rzNarwhals[NativeCuDF]rrrr^)rzNarwhals[NativePandasLike]rrrrg)rzNarwhals[NativeArrow]rrrr])rz3Narwhals[NativePolars | NativeArrow | NativePandas]rrrz&_PolarsImpl | _PandasImpl | _ArrowImpl)rzNarwhals[NativeDuckDB]rrrr`)rzNarwhals[NativeSQLFrame]rrrrk)rzNarwhals[NativeDask]rrrr_)rzNarwhals[NativeIbis]rrrrb)rz.Narwhals[NativePySpark | NativePySparkConnect]rrrz"_PySparkImpl | _PySparkConnectImpl)rrrztype[Narwhals[Any]]rr@)rzDataFrame[Any] | Series[Any]rrrra)rzLazyFrame[Any]rrrrc)rzNarwhals[Any] | Nonerrrr)rrrrrrrrrrr7r7s| "WW WW UU SS 2;> UU 5K5TW5 /55WW 09< SS SS 1F1OR1 +11NN  4 =@   TTQrr7cpddl}t||jr|jj |S|Sr)rr"RecordBatchReaderTable from_batches)tblpas rto_pyarrow_tablerSs/#r++,xx$$S)) Jrwin32cNt|tr|Stt|Sr)r"rrsources rnormalize_pathrX&s#FC0vGc$v,6GGrc4t|jSr)ras_posixrVs rrXrX/sF|$$&&rcDt|tr|f|zSt|S)zEnsure the given bool or sequence of bools is the correct length. Stolen from https://github.com/pola-rs/polars/blob/b8bfb07a4a37a8d449d6d1841e345817431142df/py-polars/polars/_utils/various.py#L580-L594 )r"rNrs)r n_matchs r extend_boolr]3s#",E4!8E8g JeElJrceZdZdZddZy) _NoDefault NO_DEFAULTcy)Nz rrs rrz_NoDefault.__repr__CsrNrL)rrr no_defaultrrrrr_r_>sJrr_)rSrrrN)r*rrr;)rSrrr)rprrz list[Any])rtrrr)rtzAny | Iterable[Any]rrN)r~zIterable[_T] | AnyrzTypeIs[Iterator[_T]])rjz#str | ModuleType | _SupportsVersionrr)rrrrrzTypeIs[type[_T]])r object | typerrrzTypeIs[_T | type[_T]])rrrtuple[type[_T1], type[_T2]]rzTypeIs[type[_T1 | _T2]])rrcrrdrz#TypeIs[_T1 | _T2 | type[_T1 | _T2]])rrr&tuple[type[_T1], type[_T2], type[_T3]]rzTypeIs[type[_T1 | _T2 | _T3]])rrcrrerz/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]])rrrztuple[type, ...]rz TypeIs[Any])rrrrrrN)rz Iterable[Any]rr)rrrz-Series[Any] | DataFrame[Any] | LazyFrame[Any]rr)rz-DataFrame[Any] | LazyFrame[Any] | Series[Any]rrr)rrrzstr | list[str] | Nonerz6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonerr)rrrr)rrrrrzTypeIs[pd.RangeIndex])rzpd.Series[Any] | pd.DataFramerrrrN)rrrprNrz bool | strrr)rrrr~rz int | float)rz Series[Any]rrN)nw)rrrContainer[str]rrrr)r rr z Iterable[str]r rNrz list[str])rSequence[_T] | AnyrTypeIs[Sequence[_T]])rrrzTypeIs[_SliceNone])rrrzCTypeIs[SizedMultiIndexSelector[Series[Any] | CompliantSeries[Any]]])rrhrz-TypeIs[Sequence[_T] | Series[Any] | _1DArray])rrrzTypeIs[_SliceIndex])rrrz TypeIs[range])rrrzTypeIs[SingleIndexSelector])rrrzTTypeIs[SingleIndexSelector | MultiIndexSelector[Series[Any] | CompliantSeries[Any]]])rrrzBTypeIs[SizedMultiBoolSelector[Series[Any] | CompliantSeries[Any]]])rrr+rrzTypeIs[list[_T]])r2zCollection[Any]rzTypeIs[Collection[list[bool]]])rrr+rrri)rrrzTypeIs[NestedLiteral])r  bool | Nonerrjr=rNrrN)r?rr@rNrz*Callable[[Callable[P, R]], Callable[P, R]])rNrrQz int | Nonerztuple[int, int])rfrrgrrr)r Collection[str]rrkrzColumnNotFoundError | None)rrkrr)rz$TimeUnit | Iterable[TimeUnit] | Nonerz7str | timezone | Iterable[str | timezone | None] | Nonerz%tuple[Set[TimeUnit], Set[str | None]]) rrprrvrz Set[TimeUnit]rzSet[str | None]rrN)r rrr)r rrrgrr)rrrzEvalNames[Any])rrrrrrN)rz\CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co] | Anyrz^TypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeDataFrameT, ToNarwhalsT_co]])rzJCompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co] | AnyrzLTypeIs[CompliantLazyFrame[CompliantExprT, NativeLazyFrameT, ToNarwhalsT_co]])rz'CompliantSeries[NativeSeriesT_co] | Anyrz)TypeIs[CompliantSeries[NativeSeriesT_co]])rrrz'TypeIs[NamespaceAccessor[_FullContext]])rhrrzTypeIs[_EagerAllowedImpl])rhrrzTypeIs[_LazyFrameCollectImpl])rhrrzTypeIs[_LazyAllowedImpl])rrrzTypeIs[SupportsNativeNamespace])rrrzTypeIs[ArrowStreamExportable])rrkrrkrrrzdict[str, str])rrYrrrpa.Table)rFrrr)rrrrN)rrrrrr)r rrrrz"tuple[int | None, int | None, Any])rzCallable[P, R1]rzr?r@rAnarwhals._compliantrBrCrD!narwhals._compliant.any_namespacerEnarwhals._compliant.typingrFrGrHrIrrKnarwhals._nativerLrMrNrOrPrQrRrSrTrUrVrWnarwhals._translaterXrYrZnarwhals._typingr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrrmrnrrprrrnarwhals.typingrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrTr r rrrrrrrrrr_r'r(rKrqrurorrgrrrrrrrrrrrrrrrrrrr r#rr&r)r,r3r8r;r>rLrSrqrr}rrrrrobjectrrrrrrr(rrrrrrrrrrrrrr r rxrRr r-r0r2r4r7rSplatformrXr]r_rbr`rrrrrrs " --$*   &:<*[Z# -HHVVC .    ZY&8%&*%( ' #3 ?&+ MN %.C %.C %.C %3 4C#A A B B8RxR00  T] \T 2 48 J iJ|< AA< i<  HZ(    x .   H -X- JHJ +^X(*? 42H 4IdIXM%ZM%`59*EF""F:6Z : 6 ).M""$9 @ < D 2&&<Q S*% L $,     -5     ""$?"" "  ..-H.(. .  (($J("( (  ::-S:4: :  #3  Y YKYYxF,0SEI S S(S B S  Sl,^8 9 MP   &* &* $&*0:&*&*R*?F:>[ [)[36[[:>)& )&))&36)&)&X #0@DL9   H  2 "D Y GJ >>#> 0    &&&)-&/&R$$#-$$0< .=""3"F"+"*     .; IX   M8 5A: :  :: S:Q: 7 07.7 ? 0?.? ? 0?.? SZ 86B B(7BADBB, # ,;$R(R(j#RRj$1'A61 IK+\ : : 2 1 *4hz6J 7x #7:3Q3Ql<<7H'K K KK " "   :r