:j^ddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z ddlmZddlmZmZddlmZmZmZmZdd lmZmZmZmZmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,e r@dd l-m.Z.dd l/m0Z0dd l1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFe dZGeHeIeJeKeLeMefZNejejejfZRe dd d2dZSe dd d3dZSe dd d4dZSe d5dZSdd d6dZSe d7dZTe d8dZTe d9dZTe d:dZTe d;dZTe dd!ZTe d?d"ZTe d@d#ZTe dAd$ZTe dBd%ZTddddd& dCd'ZTddd( dDd)ZUddd( dEd*ZVdFd+ZW dFd,ZX dGd-ddd-d& dHd.ZYdId/ZZdJd0Z[gd1Z\y)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_throughcyNnarwhals_objectr>s g/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/narwhals/translate.py to_nativerEIcyr@rArBs rDrErEMrFrGcyr@rArBs rDrErEQsrGcyr@rArBs rDrErEUsCFrGFcddlm}ddlm}t ||r|j j St ||r|jjS|sdt|d}t||S)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 rDrErEYsi&-&/9-//===/6*00777 .tO/D.EQGn rGc yr@rA native_objectkwdss rD from_nativer\zsPSrGc yr@rArYs rDr\r\|sQTrGc yr@rArYs rDr\r\~srGc yr@rArYs rDr\r\sUXrGc yr@rArYs rDr\r\!$rGc yr@rArYs rDr\r\rGc yr@rArYs rDr\r\rcrGc yr@rArYs rDr\r\rarGc yr@rArYs rDr\r\s7:rGc yr@rArYs rDr\r\s SVrGc yr@rArYs rDr\r\sLOrGcyr@rArZr> eager_only series_only allow_seriess rDr\r\s rGr>rkrlrmc Bt|||d||tjS)aConvert `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>rkct|rC|r|s d}t||S|j|jj |dSt |rX|r|s d}t||S|s|r|s d}t||S|j |jj |dSt|rC|s|s d}t||S|j|jj |dSy)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_compliantrs+./ Dn$# #   3 3 5 C CG LTZ!  ./ Dn$# # 2bn$# #   3 3 5 C CG LTZ!  +,Ln$# #~~  0 0 2 @ @ IQW   rGc  ddlm}ddlm}m} ddlm} t||| frd|sb|j|ur|S|j} |jj| jj| jSt|| rf|s|rb|j|ur|S|j} |jj| jj| jS|r|dur d} t| d}|r|r d} t| t!||||||| x} | St#|r|r2t%|s'|s#d t'|j(} t+| |S|s|rt-|r|s d } t+| |S|st%|r|s d } t+| |S|jj|jj|jSt/|rt1|r)|r:|s#d t'|j(} t+| |S|s|s d } t+| |S|jj|jj|jSt3|rt5|r)|r:|s#d t'|j(} t+| |S|s|s d } t+| |S|jj|jj|jSt7|r|r|s d } t+| |S|s|r|s d} t+| |St8j:j=dkrt? d} tA| |jjCt8j:jj|jStE|rW|s|r|s d} t+| |S|jj|jj|jStG|rW|s|r|s d} t+| |S|jj|jj|jStI|ri|jj|}|s|s|r|sd|jJd} t+| |S|jj|jS|tLjNurJ||rBddlm(}|s|r|s d} t+| |StLjNjS||dStUj||x}t!||||||| S|sAdt'|} tUjVt'|x}r| d|zz } t+| |S)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!78  ! !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'**!? !ND F n$ zz##$4]$C=#YY#// wGGT& %!&?#%   1$}2E1FG,,T--@A A4 A 6D= Cn rGc|s d}t||Dchc] }t|}}t|dk7rd|d}t||jScc}w)aGet 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_namespacerse, Mo;> ?a.q1 ?F ? 6{a@Jo ::< @sAct|r|jStjjj |j jSr@)r__native_namespace__rrtrrrto_native_namespace)rs rDrr sIC '')) << ! ! 4 4  n((*+rGTc4dfd }||S||S)aDecorate 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:tdfd }|S)Nc |Dcgc]}t|  }}|jDcic]\}}|t|  }}}g||jDchc]}t|ddx}r|} }t | dkDr d} t | |i|} t | Scc}wcc}}wcc}w)Nrnrrz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r=)r\itemsvaluesgetattrrrrE)argskwargsargargs_nwnamevalue kwargs_nwvbbackendsrWrrmrkfuncr>rls rDwrapperz.narwhalify..decorator..wrapperLs  !-) +!-  G &$*<<>  D%k!-) +!-  I 978Y%5%5%78 $:DAAAAH 8}q w o%70i0FV,? ?E  sB6B;'C)rrrrreturnrr)rrrmrkr>rls` rD decoratorznarwhalify..decoratorKs) t# @# @ # @JrG)rCallable[..., Any]rrrA)rr>rkrlrmrs ```` rD narwhalifyrs&p''R | T?rGct}|t|tr|}|Stx}r[t||jrE|j dk(r6|j tz}ttj|z}|St|s t|r|j }|S|r(t||jr|j}|S|r(t||jr|j!}|St|t"r|}|St%|rd}|St'|r|j)}|Sdt+|d|}t-|)aPIf 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_scalarrzso. Bj6OP8 M5{   {BMM 2   !1 1    = 0266* M)  % )D!!#& M% ; 5**," M! ; 5++- M K!6 7 M { # M ; '""$ M >d;>O=PPSo  orGcttx}xr8|jjj |xr|j |Sr@)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