zhddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$dd lm%Z%dd!lm&Z&dd"lm'Z'dd#lm(Z(dd$lm)Z)dd%lm*Z*dd&l+m,Z,e rHdd'l-m.Z.dd(l-m/Z/dd)l0m1Z1dd*l2m3Z3dd+l2m4Z4dd,l2m5Z5dd-l2m6Z6dd.l2m7Z7dd/l2m8Z8dd0l2m9Z9dd1l2m:Z:dd2l2m;Z;e d3Ze?e@eAeBefZCed4d5 dad6ZDed4d5 dbd7ZDed4d5 dcd8ZDeddd9ZDd:d:d; ded<ZDedfd=ZEedgd>ZEedhd?ZEed4d@ didAZEed4d4d4dB djdCZEed4d4d4dB dkdDZEed4d4dE dldFZEed4d4dE dmdGZEed4d4dH dndIZEed4d4dJ dodKZEed4d4d4d4dL dpdMZEed4d4d4d4dL dqdNZEed4d4d4dO drdPZEed4d4d4dQ dsdRZEed4d4d4dS dtdTZEe dudUZEd:d:dVdVd:dW dvdXZEdVdVdVdVd:dY dwdZZF dxd[ZG dxd\ZH dyd:d:dVdVd]dW dzd^ZId{d_ZJgd`ZKy:)|) annotations)datetime) timedelta)Decimalwraps) TYPE_CHECKING)Any)Callable)Literal)TypeVar)overload)is_native_arrow)is_native_polars)is_native_spark_like)get_cudf)get_cupy)get_dask) get_dask_expr) get_modin) get_numpy) get_pandas) get_polars) get_pyarrow)is_cudf_dataframe)is_cudf_series)is_dask_dataframe)is_duckdb_relation) is_ibis_table)is_modin_dataframe)is_modin_series)is_pandas_dataframe)is_pandas_series)is_polars_dataframe)is_polars_lazyframe)is_polars_series)is_pyarrow_chunked_array)is_pyarrow_table)Version DataFrame LazyFrameSeries) DataFrameT)IntoDataFrameT) IntoFrame) IntoFrameT)IntoLazyFrameT) IntoSeries) IntoSeriesT) LazyFrameT)SeriesTT. pass_throughcyNnarwhals_objectr;s P/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/narwhals/translate.py to_nativerBEscyr=r>r?s rArBrBIsrCcyr=r>r?s rArBrBMsrCcyr=r>r?s rArBrBQsCFrCN)strictr;cddlm}ddlm}ddlm}|||dd}t ||r|jjSt ||r|jjS|sdt|d }t||S) a<Convert Narwhals object to native one. Arguments: narwhals_object: Narwhals object. strict: Determine what happens if `narwhals_object` isn't a Narwhals class: - `True` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). 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.validate_strict_and_pass_thoughFTpass_through_defaultemit_deprecation_warningzExpected Narwhals object, got .) narwhals.dataframerInarwhals.seriesr/narwhals.utilsrK isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r@rGr;rIr/rKmsgs rArBrBUs:-&>2 5SWL/9-//===/6*00777 .tO/D.EQGn rCc yr=r> native_objectkwdss rA from_nativer_sADrCc yr=r>r\s rAr_r_GJrCc yr=r>r\s rAr_r_rarC) series_onlycyr=r>r]r; eager_onlyrc allow_seriess rAr_r_s7:rC)rfrcrgcyr=r>res rAr_r_!$rCcyr=r>res rAr_r_ rC)rcrgcyr=r>res rAr_r_rirCcyr=r>res rAr_r_rkrC)rfrccyr=r>res rAr_r_s ORrC)rfrgcyr=r>res rAr_r_rCr;rfrcrgcyr=r>res rAr_r_rirCcyr=r>res rAr_r_rirC)r;rcrgcyr=r>res rAr_r_rirC)r;rfrccyr=r>res rAr_r_s58rC)r;rfrgcyr=r>res rAr_r_ rprCcyr=r>res rAr_r_s rCF)rGr;rfrcrgc ddlm}|||dd}|r"dtt|}t |t |||d||t jS)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__` strict: Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (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. rrJFTrLz1from_native() got an unexpected keyword argument )r;rfeager_or_interchange_onlyrcrgversion)rRrKnextiterrY_from_native_implr)MAIN) r]rGr;rfrcrgr^rKrZs rAr_r_$sgb?2 5SWL A$tDzBRAUVn !"'!  rC)r;rfryrcrgc  ddlm}ddlm}ddlm} ddlm} ddlm} ddlm} ddlm } dd lm }dd lm }t|||fr|s|St|| r|s|r|S|r|d ur d }t|d }|r|r d}t|| |r+|r|s d}t||S||jdS| |r@|r|s d}t||S|s|r|s d}t||S||j!dS||r+|s|s d}t||S| |j#dSt%|rddlm}|r2t+|s'|s#dt-|j.}t||S|s|rt1|r|s d}t||S|st+|r|s d}t||S|t3}|||}|j5|}| |r ||dS| |r ||dS| |dSt7|rHddlm}|r|s d}t||St=}|||||| j>|d dStA|rGddl!m"}|s|s d}t||St=}| ||| j>|||dStG|rHddlm}tI}|r|s d}t||S|||| jJ|||d dStM|rGddl!m"}tI}|s|s d}t||S| ||| jJ|||dStO|rHddlm}tQ}|r|s d }t||S|||| jR|||d dStU|rGddl!m"}tQ}|s|s d}t||S| ||| jR|||dStW|r|r2tY|r'|s#dt-|j.}t||S|stY|s|s d}t||S|jZj]|j^j5|}| |r ||dS| |dSta|r}dd!l1m2}|r|s d"}t||S|s|r|s d#}t||S|tg}|d$krti d%}tk||||}||j5|dStm|ro|s|r|s d&}t||S|jZj]|j^j5|}|tnjpur ||d'S||dSts|r_dd(l:m;}|s|r|s d)}t||Sddl<} || }!|tnjpur||||!|d'S||||!|dSt{|r|jZj]|}"|r%d|"j|j~d*}t||s|r%d+|"j|j~d*}t|||"j^j5|dS| |r-dd,l@mA}#|s|r|s d-}t||S||#||.d'S|sd/t-|}t||S)0Nrr*r,r.)Implementation)_supports_dataframe_interchange)is_compliant_dataframe)is_compliant_lazyframe)is_compliant_series) parse_versionFzJInvalid 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`)PolarsNamespacez#Cannot only use `series_only` with zQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFrame)backend_versionrzlazy)PandasLikeDataFrame)rimplementationrzvalidate_column_names)PandasLikeSeries)rrrzz2Cannot only use `series_only` with modin.DataFrame)rrrzrz1Cannot only use `series_only` with cudf.DataFrame) DaskNamespacez1Cannot 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 DuckDBPyRelation interchange) IbisLazyFramezHCannot only use `series_only=True` or `eager_only=False` with Ibis tablez DataFramezACannot only use `eager_only` or `eager_or_interchange_only` with )InterchangeFramezhCannot only use `series_only=True` or `eager_only=False` with object which only implements __dataframe__)rzzLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )BrPr+r-rQr/rRrrrrrrrS ValueErrorrY__narwhals_dataframe____narwhals_lazyframe____narwhals_series__rnarwhals._polars.namespacerr&rX __qualname__r%rr_r"narwhals._pandas_like.dataframerrPANDASr#narwhals._pandas_like.seriesrr rMODINr!rrCUDFrrr( namespacefrom_native_object compliantrnarwhals._dask.namespacerrr ImportErrorrr)V1rnarwhals._ibis.dataframeribisrr_aliasnarwhals._interchange.dataframer)$r]r;rfryrcrgrzr+r-r/rrrrrrrZr pl_versionpl_ns pl_compliantrpdrmpdcudf pa_compliantr dask_versiondd_nsduckdb_compliantrrrns_sparkrs$ rAr}r}is-,&->552,-)Y!78-(k\ 5 ^CS/ ! /eom, Dn$   0 0 2   . Dn$ 2bn$   0 0 2   ] +Ln$   - - /  - (> / >;D>> 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: rO)r _get_native_namespace_single_objlenpop)objrZxresults rAget_native_namespacerse0 Mo;> ?a.q1 ?F ? 6{a@Jo ::< @sAcddlm}||r|jSt|s t |r t St |s t|r tSt|s t|r tSt|s t|r tSt|r t!St#|st%|s t'|r t)Sdt+|}t-|)Nr)has_native_namespacez4Could not get native namespace from object of type: )rRr__native_namespace__r"r#rr r!rr(r'rrrrrrr$r%r&rrXrY)rrrZs rArrs4C ''))3#3C#8|#/#"6{ 8 =}!4zz3#6s#;?OPS?T| @c LC C.rCTcXddlm}||dddfd }||S||S)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. strict: **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (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`: 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()) rrJTrLc:tdfd }|S)Nc |Dcgc]}t|  }}|jDcic]\}}|t|  }}}g||jDchc]}t|ddx}r|}}t |dkDr d}t | |i|} t | Scc}wcc}}wcc}w)Nrqrrz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r:)r_itemsvaluesgetattrrrrB)argskwargsargnamevaluevbbackendsrZrrgrffuncr;rcs rAwrapperz.narwhalify..decorator..wrapper;s   !-) +!-  D &$*<<>  D%k!-) +!-  F 342&--/2 $:DAAAAH 8}q w o%4*6*FV,? ?E  sB6B;'C)rr rr returnr r)rrrgrfr;rcs` rA decoratorznarwhalify..decorator:s) t# @# @ # @JrC)rCallable[..., Any]rr)rRrK)rrGr;rfrcrgrKrs ```` rA narwhalifyrsAB?2 4RVL''R |rCc|yt|tr|St}|rPt||jr:|jdk(r+t dddt |jdzzS|r-|j|rt|dr|jSt}|r&t||jr|jS|r&t||jr|jS|r:|jj j#|r |j%|}|ryt|t t fr|St)}|r&t||j*r|j-St/}|r5t||j0r|j2dk(r|jSdt5|d }t7|#t&$rYwxYw) 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]iri) microsecondsitemz/Expected object convertible to a scalar, found zH. Please report a bug to https://github.com/narwhals-dev/narwhals/issues)rSNON_TEMPORAL_SCALAR_TYPESr datetime64dtyperrrisscalarhasattrr Timestamp to_pydatetime Timedeltato_pytimedeltaapitypes is_scalarisna ExceptionrScalaras_pyrndarraysizerXr) scalar_likenpris_napacupyrZs rA to_py_scalarrjs2+89 B {BMM 2   !1 1a#i[=M=M=OSW=W&XXX bkk+&7;+G!! B jbll3((** jbll3))++ bffll$$[1 GGK(E+)45 B jbii0  "" :D K6;;K;Kq;P!! :${:K9LMQ Q S/3   s#G G('G()rrrBr)r@DataFrame[IntoDataFrameT]r;Literal[False]rr1)r@zLazyFrame[IntoFrameT]r;rrr3)r@Series[IntoSeriesT]r;rrr6)r@r r;boolrr )r@zGDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]rG bool | Noner;rrz/IntoDataFrameT | IntoFrameT | IntoSeriesT | Any)r]r8r^r rr8)r]r0r^r rr0)r]r7r^r rr7) r]zIntoDataFrameT | IntoSeriesTr; Literal[True]rfrrcrrgrrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]) r]r1r;rrfrrcrrgNonerr) r]r9r;rrfrrcrrgrrr9) r]r1r;rrfrrcrrgrrr) r]r9r;rrfrrcrrgrrr9) r]z)IntoFrameT | IntoLazyFrameT | IntoSeriesTr;rrfrrcrrgrrzGDataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]) r]r6r;rrfrrcrrgrrr) r]r4r;rrfrrcrrgrrzLazyFrame[IntoLazyFrameT]) r]r1r;rrfrrcrrgrrr) r]r1r;rrfrrcrrgrrr) r]zIntoFrame | IntoSeriesr;rrfrrcrrgrrz-DataFrame[Any] | LazyFrame[Any] | Series[Any]) r]r6r;rrfrrcrrgrrr) r]r r;rrfrrcrrgrrr )r]zFIntoLazyFrameT | IntoFrameT | IntoSeriesT | IntoFrame | IntoSeries | TrGrr;rrfrrcrrgrr^r rzKLazyFrame[IntoLazyFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T)r]r r;rrfrryrrcrrgrrzr)rr )rzFDataFrame[Any] | LazyFrame[Any] | Series[Any] | IntoFrame | IntoSeriesrr r=)rzCallable[..., Any] | NonerGrr;rrfrrcrrgrrr)rr rr )L __future__rrrdecimalr functoolsrtypingr r r r r rnarwhals._namespacerrrnarwhals.dependenciesrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(rRr)rPr+r-rQr/narwhals.typingr0r1r2r3r4r5r6r7r8r9rbytesstrintfloatcomplexrrBr_r}rrrr__all__r>rCrArs" /04***/++,,-3034/4152552:2",,&*.)*.*+*' CL      RU.AO  NQ*=K  LO(;I  F F $ --  -  -5-` D D J J J J #& :/: : :  :  :5: : "%"% $!$ $ $  $  $$ $ "%"%               #& $!$ $ $  $  $$ $ #&               "%"% R<R R R  R  RMR R "%         $'!$"% $!$!$ $  $  $$ $ $'!$"% $!$!$ $  $  $$ $ $'"% $!$!$ $  $  $$ $ $'!$"% 8)8!8 8  8  838 8 $'!$ !               $ $BYB B B  B  BB BQBP&+ $NNN N $ NNNN Nb  PD O0'+t $ $t #t t t  t  tttnJZ rC