hL %SSKJr SSKrSSKrSSKJr SSKJr SSKJr SSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSK J!r! SSK J"r" SSK J#r# SSK J$r$ SSK J%r% SSK J&r& SSK J'r' SSK J(r( SSK J)r) SS K J*r* SS!K J+r+ SS"K J,r, SS#K J-r- SS$K J.r. SS%K J/r/ SS&K J0r0 SS'K J1r1 SS(K J2r2 SS)K J3r3 SS*K J4r4 SS+K J5r5 SS,K J6r6 SS-K J7r7 SS.K8J9r9 SS/K8J:r: SS0K8J;r; \(GaSS1Kr? SSK@rASSKBrCSS3KDJErE SS4KDJFrF SS5KDJGrG SS6KDJHrH SS7KDJIrI SS8KDJJrJ SS9KKJLrL SS:KKJMrM SS;KKJNrN SSKKJQrQ SS?KKJRrR SS@KSJTrT SSAKUJVrV SSBKUJWrW SSCKXJYrY SSDKXJZrZ SSEK[J\r\ SSFK[J]r] SSGK^J_r_ SSHK`Jara SSIKbJcrc SSJKbJdrd SSKKbJere SSLKbJfrf SSMKbJgrg SSNKbJhrh SSOKbJiri SSPKbJjrj SSQKbJkrk SSRKbJlrl SSSKbJmrm SSTKbJnrn SSUKbJoro SSVKbJprp SSWKbJqrq SSXKbJrrr \"SY\\]\\\\\a\4SZ9rs\"S[5rt\"S\5ru\"S]5rv\"S^5rw\"S_S`SZ9rx\G"Sa5ry\"Sb5rz"ScSd\5r{"SeSf\5r|"SgSh\5r}"SiSj\5r~"SkSl\5r"SmSn\~\\5r"SoSp\}\\5r"SqSr\5r\"SsStSu9r\"SvStSu9r\"SwSpSZ9rSxrSy\Sz'"S{S|\\5r"S}S~\\5r"SS\5r"SS\5r\GRS\GRS\GRS\GRS\GR S\GR"S\GR$S\GR&S\GR(S\GR*S0 rS\S'SSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjr\SSj5r\SSj5r\SSj5r\SSj5r\SSj5r\SSj5r\SSj5rSSjrSSjrSSjrSSjrSSS.SSjjjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrSSS.GSSjjrGSSjrGS SjrGS SjrGS SjrGS SjrGS SjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjrGSSjr\(a#SSKr\GRS:aSSKJr O SSKDJr OGSSjr"SS5rGSSjr"SS5rGSSjrg( ) annotationsN)timezone)Enum)autowraps) find_spec)getattr_static) token_hex) TYPE_CHECKING)Any)Callable) Container)Iterable)Literal)Protocol)Sequence)TypeVar)Union)cast)overload)warn)get_cudf)get_dask)get_dask_dataframe) get_duckdb)get_ibis) get_modin) get_numpy) get_pandas) get_polars) get_pyarrow) get_pyspark)get_pyspark_sql) get_sqlframe)is_cudf_series)is_modin_series)is_narwhals_series)is_numpy_array_1d)is_pandas_dataframe)is_pandas_like_dataframe)is_pandas_like_series)is_pandas_series)is_polars_series)is_pyarrow_chunked_array)ColumnNotFoundError)DuplicateError)InvalidOperationError) ModuleType) AbstractSet) Concatenate) LiteralString) ParamSpec)Self) TypeAlias)TypeIs) CompliantExpr)CompliantExprT)CompliantFrameT)CompliantSeriesOrNativeExprT_co)CompliantSeriesT)NativeFrameT_co)NativeSeriesT_co) EvalNames)EagerAllowedImplementation Namespace)ArrowStreamExportable)IntoArrowTable DataFrame LazyFrameDTypeSeries)CompliantDataFrame)CompliantLazyFrame)CompliantSeries) DataFrameLike)DTypes) IntoSeriesT)MultiIndexSelector)SingleIndexSelector)SizedMultiIndexSelector)SizeUnit)SupportsNativeNamespace)TimeUnit)_1DArray) _SliceIndex) _SliceName) _SliceNoneFrameOrSeriesT)bound_T_T1_T2_T3_FnzCallable[..., Any]PRc \rSrSr%S\S'Srg)_SupportsVersionnstr __version__N__name__ __module__ __qualname____firstlineno____annotations____static_attributes__rn@/var/www/html/env/lib/python3.13/site-packages/narwhals/utils.pyrjrjnsrvrjc"\rSrSrSSSjjrSrg) _SupportsGetqNcgNrn)selfinstanceowners rw__get___SupportsGet.__get__rscrvrnr|)r~r r Any | Nonereturnr )rprqrrrsrrurnrvrwryryqsQQrvryc \rSrSr%S\S'Srg)_StoresImplementationtImplementation_implementationrnNrornrvrwrrts ''Mrvrc \rSrSr%S\S'Srg)_StoresBackendVersionxtuple[int, ...]_backend_versionrnNrornrvrwrrxs ))1rvrc \rSrSr%S\S'Srg)_StoresVersion|Version_versionrnNrornrvrwrr|s 0rvrc\rSrSrSrSrg)_LimitedContextz:Provides 2 attributes. - `_backend_version` - `_version` rnNrprqrrrs__doc__rurnrvrwrrs rvrc\rSrSrSrSrg) _FullContextzNProvides 3 attributes. - `_implementation` - `_backend_version` - `_version` rnNrrnrvrwrrs rvrc(\rSrSr\SSj5rSrg)_StoresColumnscgr|rnr}s rwcolumns_StoresColumns.columnss,/rvrnN)r Sequence[str])rprqrrrspropertyrrurnrvrwrrs / /rvr NativeT_coT) covariant CompliantT_co _ContextTz&Callable[Concatenate[_ContextT, P], R]r9_Methodc,\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.Nrnrs rwnative_StoresNative.native rvrnN)rr)rprqrrrsrrrrurnrvrwrr  rvrc,\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.Nrnrs rw compliant_StoresCompliant.compliantrrvrnN)rr)rprqrrrsrrrrurnrvrwrrrrvrc0\rSrSr\"5r\"5rSrg)rrnN)rprqrrrsrV1MAINrurnrvrwrrs B 6Drvrc\rSrSrSr\"5r\"5r\"5r\"5r \"5r \"5r \"5r \"5r \"5r\"5r\"5r\SSj5r\SSj5r\SSj5rSSjrSSjrSSjrSS jrSS jrSS jrSS jrSS jrSSjrSSjrSSjrSSjr SSjr!\"SSj5r#SSjr$Sr%g)rz?Implementation of native object (pandas, Polars, PyArrow, ...).c&[5[R[5[R[ 5[R [5[R[5[R[5[R[5[R[5[R [#5[R$['5[R(0 nUR+U[R,5$)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. Returns: Implementation. )r rPANDASrMODINrCUDFr"PYARROWr$PYSPARKr!POLARSrDASKrDUCKDBrIBISr%SQLFRAMEgetUNKNOWN)clsnative_namespacemappings rwfrom_native_namespace$Implementation.from_native_namespaces L.// K-- J++ M>11  ~55 L.//  ."5"5 L.// J++ NN33  {{+^-C-CDDrvc t[R[R[R[R[R [R [R[R[R[RS. nURU[R5$)zInstantiate Implementation object from a native namespace module. Arguments: backend_name: Name of backend, expressed as string. Returns: Implementation. ) pandasmodincudfpyarrowpysparkpolarsdaskduckdbibissqlframe) rrrrrrrrrrrrr)r backend_namers rw from_stringImplementation.from_strings~%++#))"''%--%--$++"''$++"''&//  {{<)?)?@@rvc[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. ) isinstancerlrrr)rbackends rw from_backendImplementation.from_backend sR'3'' OOG $ '>22 **73  rvcU[RLaSSKnU$U[RLaSSKnUR$U[R LaSSKnU$U[RLaSSKnU$U[RLaSSK nUR$U[RLaSSK nU$U[RLaSSKnUR $U[R"LaSSKnU$U[R&LaSSKn U $Sn [+U 5e)zaReturn the native namespace module corresponding to Implementation. Returns: Native module. rNzNot supported Implementation)rrrr modin.pandasrrrrr pyspark.sqlsqlrrrdask.dataframe dataframerrrrAssertionError) r}pdrrparplrrrmsgs rwto_native_namespace"Implementation.to_native_namespace s >(( ( I >'' ' <<  >&& & K >)) ) I >)) ) ;;  >(( ( I >&& & !>> ! >(( ( M >** * O,S!!rvc&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 rw is_pandasImplementation.is_pandasP~,,,,rvcfU[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 rwis_pandas_likeImplementation.is_pandas_like`s1  ! !       rvcHU[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 )rrrrs rw is_spark_likeImplementation.is_spark_likets ..0G0GHHHrvc&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 )rrrs rw is_polarsImplementation.is_polarsrrvc&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 rwis_cudfImplementation.is_cudf~****rvc&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 rwis_modinImplementation.is_modins~++++rvc&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 )rrrs rw is_pysparkImplementation.is_pyspark~----rvc&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 rw is_pyarrowImplementation.is_pyarrowrrvc&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 )rrrs rwis_daskImplementation.is_daskrrvc&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 )rrrs rw is_duckdbImplementation.is_duckdbrrvc&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 )rrrs rwis_ibisImplementation.is_ibisrrvc&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 rw is_sqlframeImplementation.is_sqlframes~....rvcN[RS[RS[RS[RS[R S[R S[RS[RS[RS [RS 0 nX$) z0Friendly name for errors. Returns: String. PandasPolarsDaskIbisModincuDFPyArrowPySparkDuckDBSQLFrame) rrrrrrrrrrr)r}rs rw_aliasImplementation._aliass  ! !8  ! !8        '     " "I  " "I  ! !8  # #Z 8 }rvc<UR5nU[R[R[R1;aUnOLU[RLa [ 5nO.U[RLa [ 5nOSSKnURn[U5$Nr) rrrrrr#rsqlframe._versionr parse_version)r}r into_versionrs rwrImplementation._backend_version)s))+   " "     # #  "L ^++ +&=L ^(( (#:L $#,,L\**rvrnN)r type[Self]rr3rr)rr)rrlrr)rr)rz!str | Implementation | ModuleTyperr)rr3)rbool)rr6)rr)&rprqrrrsrrrrrrrrrrrrr classmethodrrrrrrrrrrrrr rrrrr!rrurnrvrwrrs[I VF FE 6DfG!fG! VF 6D VF 6DvH"fG!E E+5E EE2A A'*A AA2  "C   &."`-  (I - + , . . + - + / (+rvr)r) ) )r-)rr-)i)))r-rz%dict[Implementation, tuple[int, ...]] MIN_VERSIONScNU[U=n:aSUSUSU3n[U5eg)NzMinimum version of z supported by Narwhals is z , found: )r7 ValueError)implementationbackend_version min_versionrs rwvalidate_backend_versionr=KsCn)EE+F#N#33Mk]ZcdsctuoGrvcU[RLaSSKJn U$U[RLaSSKJn U$SU3n[ U5e)Nr)dtypesCongratulations, you have entered unreachable code. Please report an issue at https://github.com/narwhals-dev/narwhals/issues. Version: )rrnarwhalsr?rnarwhals.stable.v1r)versionr? v1_dtypesrs rwimport_dtypes_modulerESsL',,# GJJ : y " S!!rvc[U[5(aU$[US5(a UR$S[S[ U5R <3n[ U5e)Nrz Expected z but got )rr_hasattr_staticrtyperp TypeError)objrs rw _into_versionrKesR#w j ) )|| gYiS (:(:'= >C C.rvc[U5nU[RLaSSKJn U$U[R LaSSKJn U$SU3n[U5e)NrrDr@)rKrrnarwhals._namespacerErnarwhals.stable.v1._namespacer)rCrErs rwimport_namespacerOnsWG$G',,1 GJJ ; y " S!!rvcNURU5(aU[U5S$U$r|) startswithlen)textprefixs rw remove_prefixrUs' vCKM"" KrvcPURU5(aUS[U5*$U$r|)endswithrR)rSsuffixs rw remove_suffixrYs) }}VNs6{l## Krvcn[[U5S:Xa[US5(a US5$U5$)Nr4r)listrR _is_iterable)argss rwflattenr^s1 CIN|DG/D/DQ PP4 PPrvcB[U[[45(dU4$U$r|)rr[tuple)args rwtupleifyrbs cD%= ) )v JrvcSSKJn [U5(d[U5(aS[ U5S3n[ U5e[ 5=nbV[XRURURUR45(aS[ U5S3n[ U5e[U[5=(a [U[[U45(+$)NrrNz(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`?)narwhals.seriesrOr*r-rHrIr!rExprrIrKrrlbytes)rarOrrs rwr\r\s&3#3C#8#88c Cuvnl'J ii",, =--7tCykB3 3 n c8 $ RZc5&=Q-R)RRrvc[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\DrhN)intresub).0vs rw parse_version..s'K4JqRVVE2q)**4Js.0.)rrlrmrkrlr`split)rC version_strs rwr&r&sK(55'7;N;NK&&[9K KK4E4Ec4JK KKrvcgr|rn obj_or_cls cls_or_tuples rwisinstance_or_issubclassrxsrvcgr|rnrus rwrxrxs rvcgr|rnrus rwrxrxs"rvcgr|rnrus rwrxrxs+.rvcgr|rnrus rwrxrxs%(rvcgr|rnrus rwrxrxs7:rvcgr|rnrus rwrxrxsrvcSSKJn [X5(a [X5$[X5=(d" [U[5=(a [ X5$)NrrL)narwhals.dtypesrMrrH issubclass)rvrwrMs rwrxrxsA%*$$*33 j / :t$MJ)Mrvc^^SSKJm SSKJm [U4SjU55(d[U4SjU55(agSUVs/sHn[ U5PM sn3n[ U5es snf)NrrHrJc3<># UHn[UT5v M g7fr|r)rmitemrIs rwro$validate_laziness..s 954:dI & &5c3<># UHn[UT5v M g7fr|r)rmrrKs rwrors :EDJtY ' 'ErzGThe items to concatenate should either all be eager, or all lazy, got: )narwhals.dataframerIrKallrHrI)itemsrrrIrKs @@rwvalidate_lazinessrsf,, 95 999 :E ::: SlqTrlqdhUYZ^U_lqTrSs tC C.Uss A.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)PandasLikeSeriesr c@UR(d Sn[U5eg)Nz'given index doesn't have a unique index) is_uniquer9)indexrs rw_validate_index*maybe_align_index.._validate_index s;CS/ !rv_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rr rNone)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrrrgetattrrrr_with_compliant _with_nativelocrrRr9)lhsrhsrrrlhs_anyrhs_anyrs rwmaybe_align_indexrsjBD=" 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 Jrvc[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) r N)r to_nativer+r,r)rJobj_any native_objs rwmaybe_get_indexr[sC:5#G""$J ++/DZ/P/P rv)rcSSKJn [SU5nUR5nUbUb Sn[U5eU(dUc Sn[U5eUb/[ U5(aUVs/sH os"USS9PM snOU"USS9nOUn[ U5(a9UR URRURU555$[U5(auSSK J n U(a S n[U5eU "UUURRURRS 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 condition 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)rr z8Only 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)r:r;)narwhals.translaterrr9r\r+rrrrr,narwhals._pandas_like.utilsrrr) rJ column_namesrrdf_anyrridxkeysrs rwmaybe_set_indexrsS^- % F!!#JE$5Ho EMCo E"";@ @%3Ys .% @5t4  ++%%  # # 0 01E1Ed1K L   z * *9 CCS/ !  00@@11BB  %%f&>&>&K&KJ&WXX 5 As$Ec[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) r T)drop) rrr+__native_namespace___has_default_indexrrr reset_indexr,r)rJrrrs rwmaybe_reset_indexrs>5#G""$J ++"779 j ; ;N&&  $ $ 1 1*2H2Hd2H2S T  Z(("779 j ; ;N&&  % % 2 2:3I3It3I3T U   Nrvc,[XR5$r|)r RangeIndex)rJrs rw_is_range_indexr s c66 77rvcURn[X!5=(aD URS:H=(a. UR[ U5:H=(a UR S:H$)Nrr4)rrstartstoprRstep)native_frame_or_seriesrrs rwrrsT # ( (E0  KK1   JJ#e* $  JJ!O rvc 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 ) rrr+rrrconvert_dtypesr,r)rJr]kwargsrrs rwmaybe_convert_dtypesrsH5#G""$J ++&&  $ $ 1 1))4:6:   Z((&&  % % 2 2))4:6:   NrvcUS;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. >brf>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got )r9)szunitrs rw scale_bytesrRss ~ $ $Dy $ $G| $ $G| $ $G|KD8Torvc\SSKJn [URR5n[ URU5(a=UR UR:Xa#URRRS$UR UR:XagUR UR:wagUR5n[U5(aUR RS:H$[U5(a[UR R"5$[%U5(aUR R"$['U5(aUR R"$[)U5(a5SSKJn U"UR.5=(a UR.R"$g)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)InterchangeSeries is_orderedTFphysical) is_dictionary)narwhals._interchange.seriesrrErrrdtype Categoricalrdescribe_categoricalrrr.orderingr-r*catorderedr'r&r/narwhals._arrow.utilsrrH)seriesrr? native_seriesrs rwis_ordered_categoricalrksJT? !&":":"C"C DF 6++->?? LLF.. .''..CCLQQ ||v{{" ||v)))$$&M &&""++z99 &&M%%--..}%%  (((m$$  ((( ..7]//0O]5G5G5O5OO rvc,Sn[USS9 [XS9$)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versions1.13.0r)n_bytesr)issue_deprecation_warninggenerate_temporary_column_name)rrrs rwgenerate_unique_tokenrs# ?cH5 )' KKrvcnSn[U5nX1;aU$US- nUS:aSU<SU3n[U5eM3)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 rr4dzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )r r)rrcountertokenrs rwrrs],G '"  L1  S=*L 3 !% % rvcURn[U5nU(a7UVs/sH oUU;dM UPM nnU(a[R"XcS9eU$[[ U5R [ U555nU$s snf)N)missing_columnsavailable_columns)rr[r0'from_missing_and_available_column_namesset intersection)compliant_framerstrictcolsto_dropxrs rwparse_columns_to_droprs  " "D7mG &-?g$1g? %MM /   Ns4y--c'l;< N@s BBcZ[U[5=(a [U[5(+$r|)rrrl)sequences rwis_sequence_but_not_strrs h ) K*Xs2K.KKrvcL[U[5=(a U[S5:H$r|)rslicerJs rw is_slice_noners c5 ! 8cU4[&88rvc[5n[U5=(a= [U5S:=(a [US[5=(d [U5S:H=(d} [ U5=(a& UR URUR5=(d> [U5=(d [U5=(a URR5$r$) rrrRrrjr) issubdtyperintegerr(is_compliant_series is_integer)rJnps rwis_sized_multi_index_selectorrs B $C ( Pc(Q,::c!fc#:NCA   c " Kr}}SYY 'K    $ @(;C(@ ' $$& rvc[U5=(d/ [U5=(d [U5=(d [U5$r|)rr)r(rrs rwis_sequence_liker s: $ $ S ! $ c " $ s # rvc<[U[5=(a [UR[5=(de [UR[5=(dD [UR [5=(a# URSL=(a URSL$r|)rrrrjrrrs rwis_slice_indexr sh c5 ! 399c" R chh $ R sxx % P#))t*; PD@Prvc"[U[5$r|)rrangers rwis_ranger s c5 !!rvcl[[U[5=(a [U[5(+5$r|)r*rrjrs rwis_single_index_selectorr#s#  3$BZT-B)B CCrvc`[U5=(d [U5=(d [U5$r|)rrr rs rwis_index_selectorr's) %  ( -  # rvcr[[U[5=(a U=(a [USU55$r$)r*rr[)rJtps rw is_list_ofr/s)  3%H#H*SVR2H IIrvcSSKnSSKJn SSKn[ U"UR 5R 5nUR5nSnU(awURU5nURU5(d4[URSS5=n(a(URS5(aURnUS- nOO U(aMwAU$!Af=f)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.r4) inspectpathlibrrArl__file__parent currentframegetfilerQrf_codef_back)rrnwpkg_dirframenfnamequalnames rwfind_stacklevelr%4s$r{{#**+G  "E AOOE*E(($U\\=$GGG''(9:: Qe   H sA^[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. rz0Can't pass both `native_namespace` and `backend`z `backend` must be specified in `z`.)poprr9rp)r]kwdsrrrfnr0r/s rwwrapper=deprecate_native_namespace..decorate..wrappershhy$/G#xx(:DA +j .cLI*!-'2EH o%!)go(8 RH o%%Ot$t$ $rv)r]P.argsr5P.kwargsrrhr)r6r7r0r/s` rwdecorate,deprecate_native_namespace..decorates% r % %  %*rv)r6Callable[P, R]rr=rn)r/r0r;s`` rwdeprecate_native_namespacer>s2 OrvczUS:a Sn[U5e[U[5(d'URRnSUS3n[ U5eUbeUS:a Sn[U5e[U[5(d'URRnSUS3n[ U5eX:a Sn[ U5eX4$UnX4$)Nr4z+window_size must be greater or equal than 1zargument 'window_size': 'z,' object cannot be interpreted as an integerz+min_samples must be greater or equal than 1zargument 'min_samples': 'z6`min_samples` must be less or equal than `window_size`)r9rrj __class__rprIr2) window_size min_samplesr_types rw_validate_rolling_argumentsrDsQ;o k3 ' '%%..'w/( ( n ??CS/ !+s++))22E+E73,, C.  $JC', , %  ##"  ##rvc [R"5RnUR 5n[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|)rR)rmlines rwro generate_repr..s>3t99u┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └) osget_terminal_sizerOSErrorrjgetenv splitlinesmaxrR) header native_reprterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrarIdiffs rw generate_reprrbs7--/77))+L>>>!~-%s6{3uv~&e,F + Ac\Q./0 PQ@QT`cdTd@d9e8ffijjAcVn%S))0Q6 .148QUV7VV  D #-.tfSI[U5RU5=n(aS[U5SU3n[U5egg)Nz Column(s) z not found in )r differencesortedr0)rsubsetmissingrs rwcheck_column_existsrhsL #f+*@*@*IIwI6'?+>'C!#&& Jrvc6[[U55n[U5U:wapSSKJn U"U5nUR 5VVs0sHupEUS:dM XE_M nnnSR SUR 555nSU3n[ U5egs snnf)Nr)Counterr4rhc38# UHupSUSUS3v M g7f)z - 'z' z timesNrn)rmkrns rwro0check_column_names_are_unique..s#L9KaS1#V,9KrKz"Expected unique column names, got:)rRr collectionsrjrjoinr1)rlen_unique_columnsrjrrlrn duplicatesrs rwcheck_column_names_are_uniquerrsS\* 7|))''"'.}}@tq!a%dad @ggL9I9I9KLL23%8S!!*As  BBcUc1SkO"[U[5(aU1O [U5nUcS1OF[U[[45(a [U51OUVs1sHo3b [U5OSiM snnX$4$s snf)N>smsnsus)rrlrr) time_unit time_zone time_unitstz time_zoness rw_parse_time_unit_and_time_zoner}s    i % %[ ^     i#x 1 1)n T$r|rn)_framers rwr6$passthrough_column_names..fn+s rv)rr rrrn)rr6s` rwpassthrough_column_namesr*s Irvc2[5n[XU5UL$r|)objectr )rJattrsentinels rwrGrG1sxH #X .h >>rvc[US5$)N__narwhals_dataframe__rGrs rwis_compliant_dataframer6 3 8 99rvc[US5$)N__narwhals_lazyframe__rrs rwis_compliant_lazyframer<rrvc[US5$)N__narwhals_series__rrs rwrrBs 3 5 66rvc[US5$)N__narwhals_expr__hasattrrs rwis_compliant_exprrHs 3+ ,,rvcU[R[R[R[R[R 1;$r|)rrrrrrrs rwis_eager_allowedrNsA   rvc[US5$)Nrrrs rwhas_native_namespacerXs 3. //rvc[US5$)N __dataframe__rrs rw_supports_dataframe_interchanger\s 3 ((rvc[US5$)N__arrow_c_stream__rrs rwsupports_arrow_c_streamr`s 3 4 55rvcH^^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 g7fr|rn)rmkeyleft_onrXs rwro(_remap_full_join_keys..ts&?G7N3%x3xs)dictzip)rright_onrXright_keys_suffixeds` ` rw_remap_full_join_keysrds% ?G H2 33rvc[S5(aISSKnSSKJn URnU"[ U5US9nUR RXS9R$S[U5R<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. rrN)ArrowNamespace)r;rC)contextz@PyArrow>=14.0.0 is required for `from_arrow` for object of type rq) r rnarwhals._arrow.namespacerrr& _dataframe from_arrowrrHrpModuleNotFoundError)datarrrrCrvrs rw_into_arrow_tablerzsw<"" M",=w O}}'''9@@@PQUVZQ[QdQdPgghi!#&&rvcU$)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) rn)r6s rwunstablers ( Irv)r-  deprecatedcSSjnU$)NcU$r|rn)funcs rwr7deprecated..wrappersKrv)rrfrrfrn)r'r7s rwrrs rvcr\rSrSrSrS S SjjrS SjrSSjrS SSjjrSSjr \ SS j5r S r g)not_implementediaIMark 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|)r!)r}aliass rw__init__not_implemented.__init__s #( rvcfS[U5RSURSUR3$)N: rq)rHrp _name_owner_namers rw__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_versionrl_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)rminimumhintrJs rwr;requires.backend_version3s"kk#"  rvc2SRSU55$)Nrqc3&# UHov M g7fr|rn)rmds rwro,requires._unparse_version..Es81#s)ro)r;s rw_unparse_versionrequires._unparse_versionCsxx8888rvc dURUR:agURnURRnUR UR5nUR UR5nSUSUSU<SU<S3 nUR (aUSUR 3n[U5e)N`z` is only available in z>=z, found version rq )rr _wrapped_namerr!rrr)r}r~methodrrfoundrs rw_ensure_versionrequires._ensure_versionGs  $ $(9(9 9 ##**11''(9(9:%%h&?&?@&0 G;FVW\V__`a ::EDJJ<(C!#&&rvcZ^^TRTl[T5SUU4Sjj5nU$)Nc>>TRU5 T"U/UQ70UD6$r|)r)r~r]r5r6r}s rwr7"requires.__call__..wrapperVs&   *h... .rv)r~rr]r9r5r:rrh)rprr)r}r6r7s`` rwrrequires.__call__Ss,[[ r /  / rv)rN)rh)rrlrrrr8)r;rrrl)r~rrr)r6_Method[_ContextT, P, R]rr) rprqrrrsrrtr+r; staticmethodrrrrurnrvrwrrsD,"! J  99 ' rvrcURbURUR5OSnURbURUR5S-OSnURnX#U4$)Nr4)rrrr) str_slicerrrrs rwconvert_str_slice_to_int_slicer_sX/8oo.IGMM)// *tE090J7== (1 ,PTD >>D  rv)r:rr;rrr)rCrrrT)rJVersion | _StoresVersionrr)rCrrztype[Namespace[Any]])rSrlrTrlrrl)rSrlrXrlrrl)r]r rz list[Any])rar rr )razAny | Iterable[Any]rr*)rCz#str | ModuleType | _SupportsVersionrr)rvrHrwrrzTypeIs[type[_T]])rv object | typerwrrzTypeIs[_T | type[_T]])rvrHrwtuple[type[_T1], type[_T2]]rzTypeIs[type[_T1 | _T2]])rvrrwrrz#TypeIs[_T1 | _T2 | type[_T1 | _T2]])rvrHrw&tuple[type[_T1], type[_T2], type[_T3]]rzTypeIs[type[_T1 | _T2 | _T3]])rvrrwrrz/TypeIs[_T1 | _T2 | _T3 | type[_T1 | _T2 | _T3]])rvr rwztuple[type, ...]rz TypeIs[Any])rvr rwr rr*)rz Iterable[Any]rr)rr`rz-Series[Any] | DataFrame[Any] | LazyFrame[Any]rr`)rJz-DataFrame[Any] | LazyFrame[Any] | Series[Any]rrr|)rJr`rzstr | list[str] | Nonerz6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonerr`)rJr`rr`)rJr rr rzTypeIs[pd.RangeIndex])rzpd.Series[Any] | pd.DataFramerr rr*)rJr`r]r*rz bool | strrr`)rrjrrYrz int | float)rz Series[Any]rr*)rrjrrrrl)rr rz Iterable[str]rr*rz list[str])rSequence[_T] | AnyrzTypeIs[Sequence[_T]])rJr rzTypeIs[_SliceNone])rJr rz$TypeIs[SizedMultiIndexSelector[Any]])rJr rz-TypeIs[Sequence[_T] | Series[Any] | _1DArray])rJr rzTypeIs[_SliceIndex])rJr rz TypeIs[range])rJr rzTypeIs[SingleIndexSelector])rJr rz5TypeIs[SingleIndexSelector | MultiIndexSelector[Any]])rJr rrrzTypeIs[list[_T]])rrj)r'rlrrlrr) r bool | Nonerr r,r*r-r*rr*)r/rlr0r*rz*Callable[[Callable[P, R]], Callable[P, R]])rArjrBz int | Nonerztuple[int, int])rWrlrXrlrrl)rrrfzSequence[str] | Nonerr)rrrr)rxz$TimeUnit | Iterable[TimeUnit] | Noneryz7str | timezone | Iterable[str | timezone | None] | Nonerz%tuple[Set[TimeUnit], Set[str | None]]) rrMr?rTrzz Set[TimeUnit]r|zSet[str | None]rr*)r!rrr)r!rrzContainer[str]rr)rrrzEvalNames[Any])rJr rrlrr*)rJzKCompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co] | AnyrzMTypeIs[CompliantDataFrame[CompliantSeriesT, CompliantExprT, NativeFrameT_co]])rJz9CompliantLazyFrame[CompliantExprT, NativeFrameT_co] | Anyrz;TypeIs[CompliantLazyFrame[CompliantExprT, NativeFrameT_co]])rJz'CompliantSeries[NativeSeriesT_co] | Anyrz)TypeIs[CompliantSeries[NativeSeriesT_co]])rJzECompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co] | AnyrzGTypeIs[CompliantExpr[CompliantFrameT, CompliantSeriesOrNativeExprT_co]])rJrrz"TypeIs[EagerAllowedImplementation])rJr rzTypeIs[SupportsNativeNamespace])rJr rzTypeIs[DataFrameLike])rJr rzTypeIs[ArrowStreamExportable])rrrrrXrlrzdict[str, str])rrGrrrzpa.Table)r6rfrrf)r'rlrzCallable[[_Fn], _Fn])rrlrrlrr)rr^rrrz"tuple[int | None, int | None, Any]) __future__rrQrkdatetimerenumrr functoolsrimportlib.utilr rr secretsr typingr r rrrrrrrrrrwarningsrnarwhals.dependenciesrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/narwhals.exceptionsr0r1r2typesr3r4Setrrrrtyping_extensionsr5r6r7r8r9r:narwhals._compliantr;r<r=r>r?r@rAnarwhals._compliant.typingrBrMrCrEnarwhals._translaterFrGrrIrKrrMrdrOnarwhals.typingrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rbrcrdrerfrgrhrjryrrrrrrrrrrrtrrrrrrrrrrrrrrr7r=rErKrOrUrYr^rbr\r&rxrrrrrrrrrrrrrrrrrr r rrrr%rr.r>rDrbrhrrr}rrrrrGrrrrrrrrrrrsys version_inforrrrrrnrvrwrs" $" **4,*++,,--1.01435:722:3.5 )-/+&+(123C4344>-92,,%&22/-&+237(7((+**ininfSk&Q RN B %.C %.C %.C %3 4C#A A8RxRNN2211 /  ,ox 00 \T 2 48 K~ 6 ==  HZ(    x .  d }+T}+B :*EF:4Z 7 3 "5D "$"&  Q S(L" $,     -5     ""$?"" "  ..-H.(. .  (($J("( (  ::-S:4: :  #3   \ \K\\~!L,0XEI X X(X B X  Xv/d8 9 MP   2 2 $20:22j2EPL L(LL"&J   $L9  2"DJ ' TU   #   6&&)-&/&R!$!$#-!$!$H<' ""3"F"+"*     .; IX   M? : T:R: : B:@: 7 07.7 - N-L- 0)64 4&34=@44,'2. 7" 6>Q(Q(h$CCL$1'rv