/_im^xddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZddlmZddlmZmZddlmZmZmZmZdd lmZmZmZmZmZmZdd l m!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 l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6dd l7m8Z8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEe dZFeGeHeIeJeKeLefZMejejejfZQedd d1dZRedd d2dZRedd d3dZRed4dZRdd d5dZRed6dZSed7dZSe d8dZSed9dZSe d:dZSe d;dZSe dd!ZSe d?d"ZSed@d#ZSe dAd$ZSddddd% dBd&ZSddd' dCd(ZTddd' dDd)ZUdEd*ZV dEd+ZW dFd,ddd,d% dGd-ZXdHd.ZYdId/ZZgd0Z[y)J) annotationsN)Decimalwraps) TYPE_CHECKINGAnyCallableLiteralTypeVaroverload)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)Unpack)AllowAny AllowLazy AllowSeries ExcludeSeries OnlySeriesPassThroughUnknown DataFrame LazyFrameSeries) DataFrameTFrameIntoDataFrameT IntoFrameIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughcyNnarwhals_objectr>s Q/var/www/html/land_sniper/venv/lib/python3.12/site-packages/narwhals/translate.py to_nativerEGcyr@rArBs rDrErEKrFrGcyr@rArBs rDrErEOsrGcyr@rArBs rDrErESsCFrGFcddlm}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 rDrErEWsi&-&/9-//===/6*00777 .tO/D.EQGn rGc yr@rA native_objectkwdss rD from_nativer\xsPSrGc yr@rArYs rDr\r\zsQTrGc 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 X ddlm}ddlm}m} ddlm} t||| fr|s|St|| r|s|r|S|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|j j#|j$j'|j)St+|rt-|r)|r:|s#d t|j} t| |S|s|s d } t| |S|j j#|j$j'|j)St/|rt1|r)|r:|s#d t|j} t| |S|s|s d } t| |S|j j#|j$j'|j)St3|r|r|s d } t| |S|s|r|s d} t| |St4j6j9dkrt; d} t=| |j j?t4j6j$j'|j)StA|rW|s|r|s d} t| |S|j j#|j$j'|j)StC|rW|s|r|s d} t| |S|j j#|j$j'|j)StE|ri|j j#|} |s|s|r|sd| jFd} t| |S| j$j'|j)S||reddlm$}|s|r|s d} t| |S|tJjLur|r|Sd} t| tJjLjO||dStQj&||}|t||||||| S|sAdt|} tQjRt|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__a+The Dataframe Interchange Protocol is no longer supported in the main `narwhals` namespace. You may want to: - Use `narwhals.stable.v1`, where it is still supported. - See https://narwhals-dev.github.io/narwhals/backcompat - Use `pass_through=True` to pass the object through without raising. interchangerwz!Unsupported dataframe type, got: z )*narwhals._interchange.dataframerrNr/r0rOr2rP ValueErrorrrr$rU __qualname__rVr# namespacefrom_native_object compliantr\ to_narwhalsrr"rr&rrDASK_backend_versionr ImportError from_backendrr rimplementationrrV1rzr _show_suggestions)rZr>rkrqrlrmrrrr/r0r2rW translatedns_sparkrrhints rDrsrs sIO7&-)Y!78-(k\ 5 ^CS/ ! /eo. %!&?#%    & / >;D+>+> ? Y{{=1 [] -( fn$    0 0 ? Y{{=1 [] ]# `n$    0 0 ? Y{{=1 [] M*$$77 F *(A$334J@ n$ !!--m<HHJJ&m4D F n$ '** $$$Y C. zz##$4]$C=#YY**='B#& %!&?#%   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 rDrrsIC '')) << ! ! 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)argskwargsargnamevaluevbbackendsrWrrmrkfuncr>rls rDwrapperz.narwhalify..decorator..wrapperFs   !-) +!-  D &$*<<>  D%k!-) +!-  F 342&--/2 $:DAAAAH 8}q w o%4*6*FV,? ?E  sB6B;'C)rrrrreturnrr)rrrmrkr>rls` rD decoratorznarwhalify..decoratorEs) t# @# @ # @JrG)rCallable[..., Any]rrrA)rr>rkrlrmrs ```` rD narwhalifyr s&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 datetime64dtypeitemrrdt timedeltar!r Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar%as_pyrUr) scalar_likepdscalarnpmsrWs rD to_py_scalarrtso. 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 r narwhalsr narwhals._constantsrrnarwhals._nativerrrrnarwhals._utilsrrrrrrnarwhals.dependenciesrrrrrrr r!r"r#r$r%r&typing_extensionsr'narwhals._translater(r)r*r+r,r-rNr/r0rOr2narwhals.typingr3r4r5r6r7r8r9r:r;r<rbytesstrintfloatcomplexrdatertimerrEr\rrsrrrrr__all__rArGrDrs"KK4  (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 TTT T $ TTTT Tn@+ 5++'+d $ d #dd d  d  ddN5pW NrG