gddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd l mZdd l mZdd l mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl mZddl m Z ddl m!Z!ddl m"Z"dd l m#Z#dd!l m$Z$dd"l m%Z%dd#l m&Z&dd$l'm(Z(er6dd%l)Z*dd%l+Z,dd%l-Z.dd&l/m0Z0dd'l/m1Z1dd(l2m3Z3dd)l4m5Z5dd*l4m6Z6dd+l4m7Z7dd,l4m8Z8e d-Z9e:e;ee?fZ@e d.d/ d\d0ZAe d.d/ d]d1ZAe d.d/ d^d2ZAe d_d3ZAd%d%d4 d`d5ZAe d.d.d6 dad7ZBe d.d.d8 dbd9ZBe d.d.d.d: dcd;ZBe d.d.d.d: ddd<ZBe d.d.d.d= ded>ZBe d.d.d.d= dfd?ZBe d.d.d.d@ dgdAZBe d.d.d.dB dhdCZBe d.d.d.d.dD didEZBe d.d.d.d.dD djdFZBe d.d.d.d.dG dkdHZBe d.d.d.d.dI dldJZBe d.d.d.d.dK dmdLZBe d.d.d.d.dM dndNZBe d.d.d.d.d.dO dodPZBe dQdR dpdSZBd%d%dQdQdQd%dT dqdUZBdQdQdQdQd%dO drdVZC dsdWZD dtd%d%dQdQdQdXdT dudYZEdvdZZFgd[ZGy%)w) annotations)datetime) timedeltawraps) TYPE_CHECKING)Any)Callable)Literal)TypeVar)overload)get_cudf)get_cupy)get_dask) get_dask_expr) get_modin) get_numpy) get_pandas) get_polars) get_pyarrow) get_pyspark)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)is_pyspark_dataframe)VersionN DataFrame LazyFrameSeries)IntoDataFrameT) IntoFrameT) IntoSeries) IntoSeriesTT. pass_throughcyNnarwhals_objectr4s G/var/www/openai/venv/lib/python3.12/site-packages/narwhals/translate.py to_nativer;Ascyr6r7r8s r:r;r;Esr<cyr6r7r8s r:r;r;Isr<cyr6r7r8s r:r;r;MsCFr<)strictr4cddlm}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.dataframerBnarwhals.seriesr-narwhals.utilsrD isinstance_compliant_frame _native_frame_compliant_series_native_seriestype TypeError)r9r@r4rBr-rDmsgs r:r;r;Qs6-&>2 5SWL/9-//===/6*00??? .tO/D.EQGn r<) eager_only series_onlycyr6r7 native_objectr4rTeager_or_interchange_onlyrU allow_seriess r: from_nativer[!$r<)rYrUcyr6r7rWs r:r[r[s7:r<)rTrUrZcyr6r7rWs r:r[r[r\r<cyr6r7rWs r:r[r[ r<)rYrUrZcyr6r7rWs r:r[r[r\r<cyr6r7rWs r:r[r[r`r<)rTrYrUcyr6r7rWs r:r[r[s KNr<)rTrYrZcyr6r7rWs r:r[r[r<)rTrYrUrZcyr6r7rWs r:r[r[58r<cyr6r7rWs r:r[r[r`r<)r4rTrUrZcyr6r7rWs r:r[r[r\r<)r4rYrUrZcyr6r7rWs r:r[r[r\r<)r4rTrYrUcyr6r7rWs r:r[r[rgr<)r4rTrYrZcyr6r7rWs r:r[r[rer<r4rTrYrUrZcyr6r7rWs r:r[r['rgr<F)rYcyr6r7rWs r:r[r[4s r<)r@r4rTrYrUrZc fddlm}|||dd}t||||||tjS)a Convert `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 eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. 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. rrCFTrE)r4rTrYrUrZversion)rKrD_from_native_implr'MAIN)rXr@r4rTrYrUrZrDs r:r[r[@sDv?2 5SWL !";!  r<c  ddlm}ddlm}ddlm} ddlm} ddlm} t|||fr|s|St|| r|s|r|S|r|dur d} t| d }|r|r d } t| t|d r+|r|s d } t| |S||jd St|dr@|r|s d} t| |S|s|r|s d} t| |S||jd St|dr+|s|s d} t| |S| |jd St|rFddlm} |r|s d} t| |St%}|| || |j&|d St)|r[ddlm}|r|s d} t| |S|s|r|s d} t| |St%}|||| |j&|dSt-|rFddlm}t%}|s|s d} t| |S| ||| |j&|d St3|rQddlm}|r|s d } t| |St9}|||| |j&| j:|d St=|rQddlm }|s|s d} t| |St9}| ||| j:| |j&|d StC|rQddlm}tE}|r|s d } t| |S|||| jF| |j&|d StI|rQddlm }tE}|s|s d} t| |S| ||| jF| |j&|d StK|rQddlm}tM}|r|s d!} t| |S|||| jN| |j&|d StQ|rQddlm }tM}|s|s d} t| |S| ||| jN| |j&|d StS|rFdd"l*m+}tY}|r|s d#} t| |S|||| |j&|d St[|rGdd$l.m/}tY}|s|s d} t| |S| ||| |j&d%|&d Sta|rpdd'l1m2}|r|s d(} t| |S|s|r|s d)} t| |Stg d*} ti| |||| tkj&|dStm|ridd+l7m8}|s|r|s d,} t| |Sddl9}| |j&}|ttjvur|||||d-S|||||d Sty|rDdd.l=m>}|s|r|s d/} t| |Sddl?}| |j&}|||||0d-St|rQdd1lAmB}|r d2} t| |s|r d3} t| |||| tj&|dSt|d4r-dd5lDmE} |s|r|s d6} t| |S|| ||7d-S|sd8t|} t| |S)9Nrr(r*r,)Implementation) parse_versionFzJInvalid parameter combination: `series_only=True` and `allow_series=False`TzUInvalid parameter combination: `eager_only=True` and `eager_or_interchange_only=True`__narwhals_dataframe__z,Cannot only use `series_only` with dataframefull)level__narwhals_lazyframe__z,Cannot only use `series_only` with lazyframezJCannot only use `eager_only` or `eager_or_interchange_only` with lazyframe__narwhals_series__z4Please set `allow_series=True` or `series_only=True`)PolarsDataFramez3Cannot only use `series_only` with polars.DataFrame)backend_versionrq)PolarsLazyFramez3Cannot only use `series_only` with polars.LazyFramezQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFramelazy) PolarsSeries)PandasLikeDataFrame)r}implementationrq)PandasLikeSeries)rr}rqz2Cannot only use `series_only` with modin.DataFramez1Cannot only use `series_only` with cudf.DataFrame)ArrowDataFramez.Cannot only use `series_only` with arrow table) ArrowSeries)r}namerq) DaskLazyFramez1Cannot only use `series_only` with dask DataFramezOCannot only use `eager_only` or `eager_or_interchange_only` with dask DataFramezPlease install dask-expr)DuckDBLazyFramezNCannot only use `series_only=True` or `eager_only=False` with DuckDBPyRelation interchange)IbisInterchangeFramezHCannot only use `series_only=True` or `eager_only=False` with Ibis table)rqr})SparkLikeLazyFramez4Cannot only use `series_only` with pyspark DataFramezRCannot only use `eager_only` or `eager_or_interchange_only` with pyspark DataFrame __dataframe__)InterchangeFramezhCannot only use `series_only=True` or `eager_only=False` with object which only implements __dataframe__)rqzLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )GrIr)r+rJr-rKrurvrL ValueErrorhasattrrRrwrzr{r!narwhals._polars.dataframer|r __version__r"r~r#narwhals._polars.seriesrrnarwhals._pandas_like.dataframerrPANDASr narwhals._pandas_like.seriesrrrMODINrrrCUDFrr%narwhals._arrow.dataframerrr$narwhals._arrow.seriesrrnarwhals._dask.dataframerr ImportErrorrrnarwhals._duckdb.dataframerduckdbr'V1rnarwhals._ibis.dataframeribisr&narwhals._spark_like.dataframerrnarwhals._interchange.dataframerrQ)!rXr4rTrYrUrZrqr)r+r-rurvrSr|plr~rrpdrmpdcudfrparrrrr}rrrrs! r:rrrrs-,&-,-)Y!78-(k\ 5 ^CS/ ! /eo}67 Dn$   0 0 2    8 9 Dn$ 2bn$   0 0 2    5 6Ln$   - - /  ] +> Kn$ \  -bnn =      ] +> Kn$ 2in$ \  -bnn =      - (8 \Ln$   -bnn =      ] +G Dn$ \  -bnn =-44      - (ALn$ \ -44 -bnn =      M *Gk Jn$  -33 -coo >       'AkLn$  -33 -coo >      = )Gz In$  -22 -d.>.> ?       &AzLn$  -22 -d.>.> ?      - (< ] Fn$   -bnn =      "- 06 ]Ln$   -bnn =      = ): In$ 2gn$ ? ",Cc" "  -hj.D.D E      M *> , C. %$'(:(:; gjj !?G$         } %A & n$ '(8(89 w     m ,E HCC. 2fCC.   -km.G.G H       0D F n$  ]G <  \]abo]p\qrn r<ct|dr|jSt|s t|r t St |s t |r tSt|s t|r tSt|s t|r tSt|r tSt!|st#|s t%|r t'Sdt)|}t+|)aGet native namespace from object. Arguments: obj: Dataframe, Lazyframe, or Series. 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) __native_namespace__z4Could not get native namespace from object of type: )rrrr rrrrr%r$rrrrrrr!r"r#rrQrR)objrSs r:get_native_namespacers>s*+''))3#3C#8|#/#"6{ 8 =}!4zz3#6s#;?OPS?T| @c LC C.r<Tc\ddlm}||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 eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. 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()) rrCTrEc<tdfd }|S)Nc |Dcgc]}t|  }}|jDcic]\}}|t|  }}}g||jDchc]}t|ddx}r|}}t |dkDr d}t | |i|} t | Scc}wcc}}wcc}w)Nrmrz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r3)r[itemsvaluesgetattrlenrr;)argskwargsargrvaluevbbackendsrSresultrZrTrYfuncr4rUs r:wrapperz.narwhalify..decorator..wrappers    C!-).G +!-    *$*<<> $2KD%k!-).G +!- $2  342&--/22A $:DAAAA2  8}q w o%4*6*FV,? ?I  sB8B=)C)rr rr returnr r)rrrZrTrYr4rUs` r: decoratorznarwhalify..decorators) t% @% @ % @Nr<)rCallable[..., Any]rr)rKrD) rr@r4rTrYrUrZrDrs ````` r: narwhalifyrJsAX?2 4RVL))V |r<c|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)rLNON_TEMPORAL_SCALAR_TYPESr datetime64dtyperrrisscalarrr Timestamp to_pydatetime Timedeltato_pytimedeltaapitypes is_scalarisna ExceptionrScalaras_pyrndarraysizerQr) scalar_likenpris_narcupyrSs r: to_py_scalarrs2+89 B {BMM 2   !1 1a#i[=M=M=OSW=W&XXX bkk+&7;+G!! B jbll3((** jbll3))++ bffll$$[1 BGGK(E+)45 B jbii0  "" :D K6;;K;Kq;P!! :${:K9LMQ Q S/3   s#G G)(G))rrr;r)r9DataFrame[IntoDataFrameT]r4Literal[False]rr.)r9zLazyFrame[IntoFrameT]r4rrr/)r9Series[IntoSeriesT]r4rrr1)r9r r4boolrr )r9CDataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]r@ bool | Noner4rrzIntoFrameT | Any)rXIntoDataFrameT | IntoSeriesTr4 Literal[True]rTrrYrrUrrZrrr)rXrr4rrTrrYrrUrrZrrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT])rXr.r4rrTrrYrrUrrZNonerr)rXr2r4rrTrrYrrUrrZrrr2)rXr.r4rrTrrYrrUrrZrrr)rXr2r4rrTrrYrrUrrZrrr2)rXIntoFrameT | IntoSeriesTr4rrTrrYrrUrrZrrr)rXr1r4rrTrrYrrUrrZrrr)rXr/r4rrTrrYrrUrrZrr-DataFrame[IntoFrameT] | LazyFrame[IntoFrameT])rXr2r4rrTrrYrrUrrZrrr2)rXr.r4rrTrrYrrUrrZrrr)rXr.r4rrTrrYrrUrrZrrr)rXrr4rrTrrYrrUrrZrrz-DataFrame[Any] | LazyFrame[Any] | Series[Any])rXr1r4rrTrrYrrUrrZrrr)rXr/r4rrTrrYrrUrrZrrr)rXr r4rrTrrYrrUrrZrrr )rXzIntoFrameT | IntoSeries | Tr@rr4rrTrrYrrUrrZrrzGLazyFrame[IntoFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T)rXr r4rrTrrYrrUrrZrrqr'rr )rzDataFrame[Any] | LazyFrame[Any] | Series[Any] | pd.DataFrame | pd.Series | pl.DataFrame | pl.LazyFrame | pl.Series | pa.Table | pa.ChunkedArrayrr r6)rzCallable[..., Any] | Noner@rr4rrTrrYrrUrrZrrr)rr rr )H __future__rrr functoolsrtypingrr r r r r narwhals.dependenciesrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&rKr'pandasrpolarsrpyarrowrrIr)r+rJr-narwhals.typingr.r/r0r1r2rbytesstrintfloatcomplexrr;r[rrrrr__all__r7r<r:rsR " ***/++,,--3034/4152552:26",,&.**+ CL     RU.AO  NQ*=K  LO(;I  F F  $ +X+ + +  +\ "%"% $/$ $ $ - $  $ $$ $ 14"% :/: : : . :  : :5: : "%"%$!$ $ $ - $  $$$ $ "%"%      -         14"%$!$ $ $ . $  $$$ $ 14"%      .         "%03"% N+N N N . N  N NIN N "%03   .     "%03"%88 8 8 . 8  8838 8 "%03"%      .         $'!$"%$!$!$ $ - $  $$$ $ $'03"%$!$!$ $ . $  $$$ $ $'!$03"% 8+8!8 8 . 8  8 838 8 $'!$03!  .     $'!$03"%88!8 8 . 8  8838 8 ',   $      $&+ $I.I I I  I $ IIIMI^&+ $JJJ J $ J  JJJ JZ . . .d'+A $&+ $A #A A A  A $ AAAAHJZ r<