Wh`|ddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZddlmZmZddlmZmZmZmZddlmZmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(e r$dd l)m*Z*m+Z+dd l,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7e d Z8e9e:e;eefZ?ejejejfZCedd d9dZDedd d:dZDedd d;dZDeddZEed?dZEed@dZEedd dAdZEedddd dBdZEedddd dCdZEeddd dDdZEeddd dEd ZEeddd! dFd"ZEeddd# dGd$ZEeddddd% dHd&ZEeddddd% dId'ZEedddd( dJd)ZEedddd* dKd+ZEedddd, dLd-ZEe dMd.ZEddddd% dNd/ZEdddddd0 dOd1ZFdPd2ZG dPd3ZH dQd4ddd4d% dRd5ZIdSd6ZJdTd7ZKgd8ZLy)U) annotationsN)Decimalwraps) TYPE_CHECKINGAnyCallableLiteralTypeVaroverload)EPOCH MS_PER_SECOND)is_native_arrowis_native_pandas_likeis_native_polarsis_native_spark_like)ImplementationVersionhas_native_namespace) 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 DataFrame LazyFrameSeries) DataFrameTFrameIntoDataFrameT IntoFrameIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughcyNnarwhals_objectr3s L/var/www/html/jupyter_env/lib/python3.12/site-packages/narwhals/translate.py to_nativer:5cyr5r6r7s r9r:r:9r;r<cyr5r6r7s r9r:r:=sr<cyr5r6r7s r9r:r:AsCFr<Fcddlm}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) BaseFramer&zExpected Narwhals object, got .) narwhals.dataframerAnarwhals.seriesr' isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r8r3rAr'msgs r9r:r:Esi&-&/9-//===/6*00777 .tO/D.EQGn r<c yr5r6 native_objectkwdss r9 from_nativerQfsADr<c yr5r6rNs r9rQrQjGJr<c yr5r6rNs r9rQrQnrSr<) series_onlycyr5r6rOr3 eager_onlyrU allow_seriess r9rQrQrs7:r<)rXrUrYcyr5r6rWs r9rQrQ}!$r<cyr5r6rWs r9rQrQ r<)rUrYcyr5r6rWs r9rQrQr[r<cyr5r6rWs r9rQrQr]r<)rXrUcyr5r6rWs r9rQrQs SVr<)rXrYcyr5r6rWs r9rQrQr<r3rXrUrYcyr5r6rWs r9rQrQr[r<cyr5r6rWs r9rQrQr[r<)r3rUrYcyr5r6rWs r9rQrQr[r<)r3rXrUcyr5r6rWs r9rQrQs58r<)r3rXrYcyr5r6rWs r9rQrQrbr<cyr5r6rWs r9rQrQs r<c |r"dtt|}t|t|||d||tj S)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. z1from_native() got an unexpected keyword argument F)r3rXeager_or_interchange_onlyrUrYversion)nextiterrK_from_native_implrMAIN)rOr3rXrUrYrPrLs r9rQrQsNX A$tDzBRAUVn !"'!  r<)r3rXrkrUrYc ddlm}ddlm}m} m} ddlm} m} ddl m } t|| | fr|s|St|| r|s|r|S|r|dur d}t|d}|r|r d }t|||rC|r|s d }t||S|j|jj!|d S| |rX|r|s d }t||S|s|r|s d}t||S|j#|j%j!|d S| |rC|s|s d}t||S|j'|j)j!|d St+|r|r2t-|s'|s#dt/|j0}t||S|s|rt3|r|s d}t||S|st-|r|s d}t||S|j4j7|j8j;|j=St?|rtA|r)|r:|s#dt/|j0}t||S|s|s d}t||S|j4j7|j8j;|j=StC|rtE|r)|r:|s#dt/|j0}t||S|s|s d}t||S|j4j7|j8j;|j=StG|r|r|s d}t||S|s|r|s d}t||StHjJjMdkrtO d}tQ||j4jStHjJj8j;|j=StU|rW|s|r|s d}t||S|j4j7|j8j;|j=StW|rW|s|r|s d}t||S|j4j7|j8j;|j=StY|ri|j4j7|}|s|s|r|sd|jZd}t||S|j8j;|j=S||reddlm.}|s|r|s d}t||S|t^j`ur|r|Sd}t|t^j`j||d S|sdt/|}t||S)Nr)supports_dataframe_interchange)is_compliant_dataframeis_compliant_lazyframeis_compliant_seriesr#r&FzJInvalid parameter combination: `series_only=True` and `allow_series=False`TzUInvalid parameter combination: `eager_only=True` and `eager_or_interchange_only=True`z,Cannot only use `series_only` with dataframefull)levelz,Cannot only use `series_only` with lazyframezJCannot only use `eager_only` or `eager_or_interchange_only` with lazyframez4Please set `allow_series=True` or `series_only=True`z#Cannot only use `series_only` with zQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFramez1Cannot 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. interchangezLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )1narwhals._interchange.dataframerrnarwhals._utilsrsrtrurCr$r%rDr'rE ValueErrorrK dataframe__narwhals_dataframe__ _with_version lazyframe__narwhals_lazyframe__series__narwhals_series__rr rJ __qualname__r namespacefrom_native_object compliantrQ to_narwhalsrrrr"rrDASK_backend_versionr ImportError from_backendrrrimplementationrzrV1)rOr3rXrkrUrYrlrrrsrtrur$r%r'rLns_sparkrzs r9roro=sO 8&-)Y!78-(k\ 5 ^CS/ ! /eom, Dn$    0 0 2 @ @ IQW!  m, Dn$ 2bn$    0 0 2 @ @ IQW!  =)Ln$ ~~  - - / = =g Ff   & / >;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 \]abo]p\qrn r<c|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`.ryz0Found objects with different native namespaces: rB)r~ _get_native_namespace_single_objlenpop)objrLxresults r9get_native_namespacerse, Mo;> ?a.q1 ?F ? 6{a@Jo ::< @sAct|r|jStjjj |j jSr5)r__native_namespace__rrprrrto_native_namespace)rs r9rr?sIC '')) << ! ! 4 4  n((*+r<Tc4dfd }||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)Nrcrryz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r2)rQitemsvaluesgetattrrr~r:)argskwargsargnamevaluevbbackendsrLrrYrXfuncr3rUs r9wrapperz.narwhalify..decorator..wrappers   !-) +!-  D &$*<<>  D%k!-) +!-  F 342&--/2 $:DAAAAH 8}q w o%4*6*FV,? ?E  sB6B;'C)rrrrreturnrr)rrrYrXr3rUs` r9 decoratorznarwhalify..decorators) t# @# @ # @Jr<)rCallable[..., Any]rrr6)rr3rXrUrYrs ```` r9 narwhalifyrIs&p''R | T?r<ct}|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-|)auIf a scalar is not Python native, converts it to Python native. Arguments: scalar_like: Scalar-like value. Returns: Python scalar. 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. )rrENON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltarr Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar!as_pyrJr~) scalar_likepdscalarnpmsrLs r9 to_py_scalarrso4 Bj6OP8 M5{   {BMM 2   !1 1    = 0266* M)  % )D!!#& M% ; 5**," M! ; 5++- M K!6 7 M { # M ; '""$ M >d;>O=PPSo  or<cttx}xr8|jjj |xr|j |Sr5)boolrapitypes is_scalarisna)rrs r9rrs: z|#U)?)?)DUQT VVr<)rrr:r)r8DataFrame[IntoDataFrameT]r3Literal[False]rr*)r8LazyFrame[IntoLazyFrameT]r3rrr,)r8Series[IntoSeriesT]r3rrr.)r8rr3rrr)r8KDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]r3rrz3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Any)rOr0rPrrr0)rOr(rPrrr()rOr/rPrrr/) rOzIntoDataFrameT | IntoSeriesTr3 Literal[True]rXrrUrrYrrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]) rOr*r3rrXrrUrrYNonerr) rOr1r3rrXrrUrrYrrr1) rOr*r3rrXrrUrrYrrr) rOr1r3rrXrrUrrYrrr1) rOz-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTr3rrXrrUrrYrrr) rOr.r3rrXrrUrrYrrr) rOr,r3rrXrrUrrYrrr) rOr*r3rrXrrUrrYrrr) rOr*r3rrXrrUrrYrrr) rOzIntoFrame | IntoSeriesr3rrXrrUrrYrrz-DataFrame[Any] | LazyFrame[Any] | Series[Any]) rOr.r3rrXrrUrrYrrr) rOrr3rrXrrUrrY bool | Nonerr)rOzJIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | Tr3rrXrrUrrYrrPrrzOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | T)rOrr3rrXrrkrrUrrYrrlrrr)rz,Frame | Series[Any] | IntoFrame | IntoSeriesrrr5) rzCallable[..., Any] | Noner3rrXrrUrrYrrr)rrrr)rrrr)M __future__rdatetimerdecimalr functoolsrtypingrrr r r r narwhals._constantsr rnarwhals._namespacerrrrr}rrrnarwhals.dependenciesrrrrrrrrrrr r!r"rCr$r%rDr'narwhals.typingr(r)r*r+r,r-r.r/r0r1rbytesstrintfloatcomplexrdatertimerr:rQrorrrrr__all__r6r<r9rsY"KK4 JI 7&    CL!5#sE7GL",,8 RU.AO  RU.AO  LO(;I  F F    9 B D D J J J J #& :/: : :  :  :5: : "%"% $!$ $ $  $  $$ $ "%"%               #& $!$ $ $  $  $$ $ #&               "%"% V@V V V  V  VQV V "%         $'!$"% $!$!$ $  $  $$ $ $'!$"% $!$!$ $  $  $$ $ $'"% $!$!$ $  $  $$ $ $'!$"% 8)8!8 8  8  838 8 $'!$ !              $ $888888 8U8|&+ $___ _ $ ____ _D@+ 5++'+d $ d #dd d  d  ddN8vW Nr<