Lpj^SSKJr SSKrSSKJr SSKJr SSKJ r J r J r J r J r SSKJr SSKJrJr SSKJrJrJrJr SS KJrJrJrJrJrJr SS KJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r, \ (a@SS K-J.r. SS K/J0r0 SS K1J2r2J3r3J4r4J5r5J6r6J7r7 SSK8J9r9J:r: SSK;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrF \ "S5rG\H\I\J\K\L\M\4rN\R\R\R4rR\ SS.S2Sjj5rS\ SS.S3Sjj5rS\ SS.S4Sjj5rS\ S5Sj5rSSS.S6SjjrS\ S7Sj5rT\ S8Sj5rT\ S9Sj5rT\ S:Sj5rT\ S;Sj5rT\ SS!j5rT\ S?S"j5rT\ S@S#j5rT\ SAS$j5rT\ SBS%j5rTSSSSS&.SCS'jjrTSSS(.SDS)jjrUSSS(.SES*jjrVSFS+jrWSFS,jrXSGS-SSS-S&.SHS.jjjrYSIS/jrZSJS0jr[/S1Qr\g)K) annotationsN)Decimalwraps) TYPE_CHECKINGAnyLiteralTypeVaroverload)plugins)EPOCH MS_PER_SECOND)is_native_arrowis_native_pandas_likeis_native_polarsis_native_spark_like)ImplementationVersionhas_native_namespaceis_compliant_dataframeis_compliant_lazyframeis_compliant_series) get_dask_expr get_numpy get_pandasis_cupy_scalaris_dask_dataframeis_duckdb_relation is_ibis_tableis_numpy_scalaris_pandas_like_dataframeis_polars_lazyframeis_polars_seriesis_pyarrow_scalaris_pyarrow_table)Callable)Unpack)AllowAny AllowLazy AllowSeries ExcludeSeries OnlySeriesPassThroughUnknown DataFrame LazyFrameSeries) DataFrameTFrameIntoDataFrameT IntoFrameIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughcgNnarwhals_objectr>s N/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/translate.py to_nativerEIcgr@rArBs rDrErEMrFrGcgr@rArBs rDrErEQsrGcgr@rArBs rDrErEUsCFrGFcSSKJn SSKJn [ X5(aUR R $[ X5(aURR$U(dS[U5S3n[U5eU$)a=Convert Narwhals object to native one. Arguments: narwhals_object: Narwhals object. pass_through: Determine what happens if `narwhals_object` isn't a Narwhals class - `False` (default): raise an error - `True`: pass object through as-is Returns: Object of class that user started with. r) BaseFramer1zExpected Narwhals object, got .) narwhals.dataframerLnarwhals.seriesr2 isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)rCr>rLr2msgs rDrErEYsk&-&/--//===/**00777 .tO/D.EQGn rGc gr@rA native_objectkwdss rD from_nativer\zsPSrGc gr@rArYs rDr\r\|sQTrGc gr@rArYs rDr\r\~srGc gr@rArYs rDr\r\sUXrGc gr@rArYs rDr\r\!$rGc gr@rArYs rDr\r\rGc gr@rArYs rDr\r\rcrGc gr@rArYs rDr\r\rarGc gr@rArYs rDr\r\s7:rGc gr@rArYs rDr\r\s SVrGc gr@rArYs rDr\r\sLOrGcgr@rArZr> eager_only series_only allow_seriess rDr\r\s rGr>rkrlrmc <[UUUSUU[RS9$)a5Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series. Arguments: native_object: Raw object from user. Depending on the other arguments, input object can be - a Dataframe / Lazyframe / Series supported by Narwhals (pandas, Polars, PyArrow, ...) - an object which implements `__narwhals_dataframe__`, `__narwhals_lazyframe__`, or `__narwhals_series__` pass_through: Determine what happens if the object can't be converted to Narwhals - `False` (default): raise an error - `True`: pass object through as-is eager_only: Whether to only allow eager objects - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager series_only: Whether to only allow Series - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe) - `False` or `None` (default): don't convert to Narwhals if `native_object` is a Series - `True`: allow `native_object` to be a Series Returns: DataFrame, LazyFrame, Series, or original object, depending on which combination of parameters was passed. Fr>rkeager_or_interchange_onlyrlrmversion)_from_native_implrMAINrjs rDr\r\s+V !"'!  rG)r>rkch[U5(aJU(aU(d Sn[U5eU$URUR5R U5SS9$[ U5(anU(aU(d Sn[U5eU$U(dU(aU(d Sn[U5eU$UR UR5R U5SS9$[U5(aJU(dU(d Sn[U5eU$URUR5R U5SS9$g)Nz,Cannot only use `series_only` with dataframefulllevelz,Cannot only use `series_only` with lazyframezJCannot only use `eager_only` or `eager_or_interchange_only` with lazyframe4Please set `allow_series=True` or `series_only=True`) rrV dataframe__narwhals_dataframe__ _with_versionr lazyframe__narwhals_lazyframe__rseries__narwhals_series__)compliant_objectr>rkrqrlrmrrrWs rD_translate_if_compliantrs4.// Dn$# #   3 3 5 C CG LTZ!  .// Dn$# # 2bn$# #   3 3 5 C CG LTZ!  +,,Ln$# #~~  0 0 2 @ @ IQW   rGc  SSKJn SSKJnJn SSKJn [XU 45(ajU(dcURULaU$UR5n URRU 5RRU 5R5$[X 5(aqU(dU(acURULaU$UR5n URRU 5RRU 5R5$U(aUSLa Sn [U 5eSnU(aU(a Sn [U 5e[!UUUUUUUS 9=n bU $[#U5(aU(a<[%U5(d,U(d#S ['U5R(3n [+U 5eU$U(dU(a&[-U5(aU(d S n [+U 5eU$U(d&[%U5(aU(d S n [+U 5eU$URRU5RRU5R5$[/U5(a[1U5(a4U(a,U(d#S ['U5R(3n [+U 5eU$OU(dU(d S n [+U 5eU$URRU5RRU5R5$[3U5(a[5U5(a4U(a,U(d#S ['U5R(3n [+U 5eU$OU(dU(d S n [+U 5eU$URRU5RRU5R5$[7U5(aU(aU(d S n [+U 5eU$U(dU(aU(d Sn [+U 5eU$[8R:R=5S::a[?5c Sn [AU 5eURRC[8R:5RRU5R5$[EU5(afU(dU(aU(d Sn [+U 5eU$URRU5RRU5R5$[GU5(afU(dU(aU(d Sn [+U 5eU$URRU5RRU5R5$[IU5(a}URRU5nU(dU(dU(a$U(dSURJS3n [+U 5eU$URRU5R5$U[LRNLa[U"U5(aNSSKJ(n U(dU(aU(d Sn [+U 5eU$[LRNRSU"U5SS9$[TR"X5=nb[!UUUUUUUS 9$U(dGS['U53n [TRV"['U55=n(aU SU-- n [+U 5eU$)Nr)supports_dataframe_interchanger.r1FzJInvalid parameter combination: `series_only=True` and `allow_series=False`TzUInvalid parameter combination: `eager_only=True` and `eager_or_interchange_only=True`rpz#Cannot only use `series_only` with zQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFrameryz1Cannot only use `series_only` with dask DataFramezOCannot only use `eager_only` or `eager_or_interchange_only` with dask DataFrame)i zPlease install dask-exprzNCannot only use `series_only=True` or `eager_only=False` with DuckDBPyRelationzHCannot only use `series_only=True` or `eager_only=False` with ibis.TablezPCannot only use `series_only`, `eager_only` or `eager_or_interchange_only` with z DataFrame)InterchangeFramezhCannot only use `series_only=True` or `eager_only=False` with object which only implements __dataframe__ interchangerwz!Unsupported dataframe type, got: z ),narwhals._interchange.dataframerrNr/r0rOr2rP_versionrE namespacefrom_native_object compliantr\ to_narwhals ValueErrorrrr#rU __qualname__rVr"rr!rr%rrDASK_backend_versionr ImportError from_backendrrrimplementationrV1rrzr _show_suggestions)rZr>rkrqrlrmrrrr/r0r2real_native_objectrW translatedns_sparkrrhints rDrsrssO7&-Y!788  ! !W , *446    0 01C D Y{{#56 [] -((k\  ! !W , *446    0 01C D Y{{#56 []  5 ^CS/ ! /eo. %!&?#%    && / >>;D+>+> ? Y{{=1 [] -(( fn$    0 0 ? Y{{=1 [] ]## `n$    0 0 ? Y{{=1 [] M**$$77 F *(A$334J@ n$ !!--m<HHJJ'**!? !N!ND F n$ zz##$4]$C=#YY#// GGT& %!&?#%   1$}2E1FG,,T--@A A4 A 6D= Cn rGcU(d Sn[U5eUVs1sHn[U5iM nn[U5S:waSUS3n[U5eUR5$s snf)a[Get native namespace from object. Arguments: obj: Dataframe, Lazyframe, or Series. Multiple objects can be passed positionally, in which case they must all have the same native namespace (else an error is raised). Returns: Native module. Examples: >>> import polars as pl >>> import pandas as pd >>> import narwhals as nw >>> df = nw.from_native(pd.DataFrame({"a": [1, 2, 3]})) >>> nw.get_native_namespace(df) >>> df = nw.from_native(pl.DataFrame({"a": [1, 2, 3]})) >>> nw.get_native_namespace(df) z=At least one object must be passed to `get_native_namespace`.rz0Found objects with different native namespaces: rM)r _get_native_namespace_single_objlenpop)objrWxresults rDget_native_namespacersf, Mo;> ?3a.q13F ? 6{a@Jo ::< @sA c[U5(aUR5$[RRR U5R R5$r@)r__native_namespace__rrtrrrto_native_namespace)rs rDrr sLC  '')) << ! ! 4 4  n((*+rGTc:^^^^SUUUU4SjjnUcU$U"U5$)a,Decorate function so it becomes dataframe-agnostic. This will try to convert any dataframe/series-like object into the Narwhals respective DataFrame/Series, while leaving the other parameters as they are. Similarly, if the output of the function is a Narwhals DataFrame or Series, it will be converted back to the original dataframe/series type, while if the output is another type it will be left as is. By setting `pass_through=False`, then every input and every output will be required to be a dataframe/series-like object. Arguments: func: Function to wrap in a `from_native`-`to_native` block. pass_through: Determine what happens if the object can't be converted to Narwhals - `False`: raise an error - `True` (default): pass object through as-is eager_only: Whether to only allow eager objects - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager series_only: Whether to only allow Series - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe) - `False` or `None`: don't convert to Narwhals if `native_object` is a Series - `True` (default): allow `native_object` to be a Series Returns: Decorated function. Examples: Instead of writing >>> import narwhals as nw >>> def agnostic_group_by_sum(df): ... df = nw.from_native(df, pass_through=True) ... df = df.group_by("a").agg(nw.col("b").sum()) ... return nw.to_native(df) you can just write >>> @nw.narwhalify ... def agnostic_group_by_sum(df): ... return df.group_by("a").agg(nw.col("b").sum()) c>>^[T5SUUUUU4Sjj5nU$)Nc >UVs/sHn[UTT TT S9PM nnUR5VVs0sHupEU[UTT TT S9_M nnn/UQUR5Q7Vs1sH n[USS5=n(dMU"5iM" n n[ U 5S:a Sn [ U 5eT"U0UD6n [ U TS9$s snfs snnfs snf)Nrnrrz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r=)r\itemsvaluesgetattrrrrE)argskwargsargargs_nwnamevalue kwargs_nwvbbackendsrWrrmrkfuncr>rls rDwrapper.narwhalify..decorator..wrapperLs   C!-) +!-    &$*<<> $2KDk!-) +!- $2  978Y%5%5%788A $:DAAAA8  8}q w o%70i0FV,? ?E  sB=C&C C)rrrrreturnrr)rrrmrkr>rls` rD decoratornarwhalify..decoratorKs) t# @# @ # @JrG)rCallable[..., Any]rrrA)rr>rkrlrmrs ```` rD narwhalifyrs&p''R | T?rGc4[5nUb[U[5(aUnU$[5=n(a^[XR5(aDUR S:Xa4UR 5[-n[[R"US9-nU$[U5(d[U5(aUR 5nU$U(a,[XR5(aUR5nU$U(a,[XR5(aUR!5nU$[U["5(aUnU$[%U5(aSnU$['U5(aUR)5nU$S[+U5SU<3n[-U5e)a If a scalar is not Python native, converts it to Python native. Arguments: scalar_like: Scalar-like value. Raises: ValueError: If the object is not convertible to a scalar. Examples: >>> import narwhals as nw >>> import pandas as pd >>> df = nw.from_native(pd.DataFrame({"a": [1, 2, 3]})) >>> nw.to_py_scalar(df["a"].item(0)) 1 >>> import pyarrow as pa >>> df = nw.from_native(pa.table({"a": [1, 2, 3]})) >>> nw.to_py_scalar(df["a"].item(0)) 1 >>> nw.to_py_scalar(1) 1 Nzdatetime64[ns]) microsecondsz/Expected object convertible to a scalar, found z. )rrPNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltar r Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar$as_pyrUr) scalar_likepdscalarnpmsrWs rD to_py_scalarrzs. Bj6OPP8 M5{   {MM 2 2   !1 1    = 0266* M)  % % )D)D!!#& M% ; 55**," M! ; 55++- M K!6 7 7 M { # # M ; ' '""$ M >d;>O=PPSo  orGc[[5=n=(a= URRR U5=(a UR U55$r@)boolrapitypes is_scalarisna)rrs rDrrs: z|#U)?)?)DUQT VVrG)rrrEr)rCDataFrame[IntoDataFrameT]r>Literal[False]rr5)rCLazyFrame[IntoLazyFrameT]r>rrr7)rCSeries[IntoSeriesT]r>rrr9)rCrr>rrr)rCKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]r>rrz3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Any)rZr;r[Unpack[OnlySeries]rr;)rZr;r[Unpack[AllowSeries]rr;)rZr3r[Unpack[ExcludeSeries]rr3)rZr:r[Unpack[AllowLazy]rr:)rZr5r[rrr)rZr9r[rrr)rZr9r[rrr)rZr7r[rrr)rZzIntoDataFrameT | IntoSeriesTr[rrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT])rZz-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTr[zUnpack[AllowAny]rr)rZr<r[zUnpack[PassThroughUnknown]rr<) rZrr>rrkrrlrrm bool | Nonerr) rZzJIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | Tr>rrkrrlrrmrrzOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T)rrr>rrkrrqrrlrrmrrrrrr)rZrr>rrkrrqrrlrrmrrrrrr)rz,Frame | Series[Any] | IntoFrame | IntoSeriesrrr@) rzCallable[..., Any] | Noner>rrkrrlrrmrrr)rrrr)rrrr)] __future__rdatetimerdecimalr functoolsrtypingrrr r r narwhalsr narwhals._constantsr rnarwhals._nativerrrrnarwhals._utilsrrrrrrnarwhals.dependenciesrrrrrrrr r!r"r#r$r%collections.abcr&typing_extensionsr'narwhals._translater(r)r*r+r,r-rNr/r0rOr2narwhals.typingr3r4r5r6r7r8r9r:r;r<rbytesstrintfloatcomplexrdatertimerrEr\rrsrrrrr__all__rArGrDrs"AA4  ((8&    CL!5#sE7GL",,8 RU.AO  RU.AO  LO(;I  F F    9 B S S T T '<  X X $!$+@$$ $ (:  (;  $!$+<$$ $ :/:9L:4: : V@VJZVPV V O O          $333333U3r ,,, , $ ,,,, ,d XXX X $ XXXX Xv@+ 5++'+d $ d #dd d  d  ddN5pW NrG