}ii^ddlmZddlZddlmZddlmZddlm 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 dZFeGeHeIeJeKeLefZMejNejOejPfZQeddd]dZReddd^dZReddd_dZRed`d"ZRd#ddad&ZRedbd+ZSedcd-ZSeddd0ZSeded3ZSedfd4ZSedgd5ZSedhd6ZSedid7ZSedjd:ZSedkd=ZSedld?ZSedmdDZSd#d#d#ddEdndHZSd#d#dIdodNZTd#d#dIdpdOZUdqdRZVdqdSZW drdTd#d#dTdEdsdXZXdtdZZYdud[ZZgd\Z[dS)v) 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_throughnarwhals_objectDataFrame[IntoDataFrameT]r>Literal[False]returnr5cdSNr?r>s F/home/jrussi/.local/lib/python3.11/site-packages/narwhals/translate.py to_nativerHG SLazyFrame[IntoLazyFrameT]r7cdSrDrErFs rGrHrHKrIrJSeries[IntoSeriesT]r9cdSrDrErFs rGrHrHOs #rJrboolcdSrDrErFs rGrHrHSsCF3rJFKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | Anycddlm}ddlm}t ||r |jjSt ||r |jjS|s"dt|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.dataframerTnarwhals.seriesr2 isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r?r>rTr2msgs rGrHrHWs&-,,,,,&&&&&&/9-->/==/6**8077 GtO/D/DGGGnn rJ native_objectr;kwdsUnpack[OnlySeries]c dSrDrEr`ras rG from_nativerexsPSPSrJUnpack[AllowSeries]c dSrDrErds rGrerezsQTQTrJr3Unpack[ExcludeSeries]c dSrDrErds rGrere|s rJr:Unpack[AllowLazy]c dSrDrErds rGreresUXUXrJc dSrDrErds rGrere !$rJc dSrDrErds rGrere #rJc dSrDrErds rGrererorJc dSrDrErds rGrerermrJIntoDataFrameT | IntoSeriesT/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]c dSrDrErds rGreres 7:crJ-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTUnpack[AllowAny]c dSrDrErds rGreres SVRUrJUnpack[PassThroughUnknown]c dSrDrErds rGreresLOCrJ eager_only series_only allow_series bool | NonecdSrDrEr`r>rzr{r|s rGreres  #rJr>rzr{r|JIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | TOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | Tc 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>rzeager_or_interchange_onlyr{r|version)_from_native_implrMAINrs rGreres3V !"'!    rJ)r>rzcompliant_objectrrrct|rS|r|sd}t||S|||dSt |rl|r|sd}t||S|s|r|sd}t||S|||dSt|rS|s|sd}t||S| | |dSdS)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`) rr^ dataframe__narwhals_dataframe__ _with_versionr lazyframe__narwhals_lazyframe__rseries__narwhals_series__)rr>rzrr{r|rr_s rG_translate_if_compliantrs.//  $ %Dnn$# #   3 3 5 5 C CG L LTZ!   .//   $ %Dnn$# #  $2 $ %bnn$# #   3 3 5 5 C CG L LTZ!   +,,  $ %Lnn$# #~~  0 0 2 2 @ @ I IQW    4rJc  ddlm}ddlm}m} ddlm} t||| fre|sc|j|ur|S| } |j | j | St|| rg|s|rc|j|ur|S| } |j | j | S|r|durd} t| d}|r|rd} t| t!||||||| x} | St#|r|r9t%|s*|s&d t'|j} t+| |S|s|r$t-|r|sd } t+| |S|s$t%|r|sd } t+| |S|j |j |St/|rt1|r-|r*|s&d t'|j} t+| |Sn|s|sd } t+| |S|j |j |St3|rt5|r-|r*|s&d t'|j} t+| |Sn|s|sd } t+| |S|j |j |St7|r|r|sd } t+| |S|s|r|sd} t+| |St8jdkrt?d} tA| |j !t8jj |StE|r]|s|r|sd} t+| |S|j |j |StG|r]|s|r|sd} t+| |S|j |j |StI|rj|j |}|s|s|r|sd|j%d} t+| |S|j |S|tLj'urT||rIddlm(}|s|r|sd} t+| |StLj')||dStUj ||x}t!||||||| S|sLdt'|} tUj+t'|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`rz#Cannot only use `series_only` with zQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFramerz1Cannot 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__ interchangerz!Unsupported dataframe type, got: z ),narwhals._interchange.dataframerrVr/r0rWr2rX_versionrH namespacefrom_native_object compliantre to_narwhals ValueErrorrrr$r] __qualname__r^r#rr"rr&rrDASK_backend_versionr ImportError from_backendrr rimplementationrV1rrr _show_suggestions)r`r>rzrr{r|rrr/r0r2real_native_objectr_ translatedns_sparkrrhints rGrr sONNNNN77777777&&&&&&-)Y!788     !W , , *4466   0 01C D D {{#566 []] -((  k  \   !W , , *4466   0 01C D D {{#566 []]  5 ^CS// ! /eoo. %!&?#%      &&  !/ >> ! %^D+> ? ? {{=11 []] -((   ! ! %fnn$   0 0 ? ? {{=11 []] ]##   ! ! %`nn$   0 0 ? ? {{=11 []] M** K$77 FF  !* !(A ! %@$3@@@ nn$ !--m<<HHJJJ'*!?!? !N!NDDDDDD  ! ! %F nn$ z##$4$4]$C$C=#YYY#/ wGGGT& %!&?#%     G$}2E2EGG,T--@-@AA A4 ! 6D= Cnn rJobj,Frame | Series[Any] | IntoFrame | IntoSeriesc|sd}t|d|D}t|dkrd|d}t||S)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`.c,h|]}t|SrE) _get_native_namespace_single_obj).0xs rG z'get_native_namespace..s! ? ? ?a.q11 ? ? ?rJrz0Found objects with different native namespaces: rU)rlenpop)rr_results rGget_native_namespacersk, Moo ? ?3 ? ? ?F 6{{aJJJJoo ::<<rJct|r|Stjj|jSrD)r__native_namespace__rrrrrto_native_namespace)rs rGrrsUC  *''))) < ! 4 4   ((**+rJTfuncCallable[..., Any] | NoneCallable[..., Any]c:dfd }||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()) rrrBcHtdfd }|S)NargsrkwargsrBc2 fd|D} fd|D}fdg||RD}t|dkrd}t| |i|}t | S)Nc 8g|]}t|Srre)rargr|rzr>r{s rG zBnarwhalify..decorator..wrapper..LsI   !-) +!-    rJc @i|]\}}|t|Srr)rnamevaluer|rzr>r{s rG zBnarwhalify..decorator..wrapper..WsO    D%k!-) +!-    rJcJh|]}t|ddx S)rN)getattr)rvbs rGrzAnarwhalify..decorator..wrapper..bsG $:DAAAArJrz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r=)itemsvaluesrrrH) rrargs_nw kwargs_nwbackendsr_rrr|rzrr>r{s @rGwrapperz.narwhalify..decorator..wrapperJs            G       $*<<>>   I878Y%5%5%7%788H 8}}q  w oo%T70i00FV,??? ?rJ)rrrrrBrr)rrr|rzr>r{s` rG decoratorznarwhalify..decoratorIsX t# @# @# @# @# @# @# @# @# @ # @JrJN)rrrBrrE)rr>rzr{r|rs ```` rG narwhalifyrsPp'''''''''R | 9T??rJ scalar_likec&t}|t|tr|}ngtx}rZt||jrE|jdkr:|tz}ttj |z}nt|st|r|}n|r*t||j r|}n|r*t||jr|}nrt|t"r|}nZt%|rd}nHt'|r|}n$dt+|d|}t-||S)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. )rrXNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrrdt timedeltar!r Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar%as_pyr]r)rpdscalarnpmsr_s rG to_py_scalarrxs. Bj6OPP{{  {BM 2 2  !1 1 1     = 026666  % % )D)D!!##  ; 55**,,  ; 55++-- K!6 7 7  { # #  ; ' '""$$ d;>O>O     oo MrJcttx}o3|jj|o||SrD)rOrapitypes is_scalarisna)rrs rGrrs@ z||#U)?)?)D)DUQT V VVrJ)rrrHr)r?r@r>rArBr5)r?rKr>rArBr7)r?rMr>rArBr9)r?rr>rOrBr)r?rQr>rOrBrR)r`r;rarbrBr;)r`r;rarfrBr;)r`r3rarhrBr3)r`r:rarjrBr:)r`r5rarhrBr@)r`r9rarbrBrM)r`r9rarfrBrM)r`r7rarjrBrK)r`rrrarfrBrs)r`rurarvrBrQ)r`r<rarxrBr<) r`rr>rOrzrOr{rOr|r}rBr) r`rr>rOrzrOr{rOr|r}rBr)rrr>rOrzrOrrOr{rOr|r}rrrBr)r`rr>rOrzrOrrOr{rOr|r}rrrBr)rrrBrrD) rrr>rOrzrOr{rOr|r}rBr)rrrBr)rrrBrO)\ __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-rVr/r0rWr2narwhals.typingr3r4r5r6r7r8r9r:r;r<rObytesstrintfloatcomplexrdatertimerrHrerrrrrrr__all__rErJrGr sF""""""KKKKKKKKKKKKKKKK44444444  ((((((87777777&&&&&&                       GCLL!5#sE7GL",8 RU  RU  LO  FFF F B SSS S TTT T   XXX X $$$ $     $$$ $ ::: : VVV V OOO O    $333333r ,,,,,,d XXXXXXv@++++'+d $ ddddddN5555pWWWW N M MrJ