o $&]im^@sddlmZddlZddlmZddlmZddlm 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 rdd l.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6dd l7m8Z8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEe dZFeGeHeIeJeKeLefZMejNejOejPfZQedddfddZRedddgddZRedddhd dZRedid#dZRd$ddjd'dZRedkd,d-ZSedld/d-ZSedmd2d-ZSednd5d-ZSedod6d-ZSedpd7d-ZSedqd8d-ZSedrd9d-ZSedsdr=rDrDP/var/www/html/IGF-ODF-V3/venv/lib/python3.10/site-packages/narwhals/translate.py to_nativeGrGLazyFrame[IntoLazyFrameT]r6cCrBrCrDrErDrDrFrGKrHSeries[IntoSeriesT]r8cCrBrCrDrErDrDrFrGOrHrboolcCrBrCrDrErDrDrFrGSFKDataFrame[IntoDataFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]3IntoDataFrameT | IntoLazyFrameT | IntoSeriesT | AnycCs\ddlm}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) BaseFramer0zExpected Narwhals object, got .) narwhals.dataframerOnarwhals.seriesr1 isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r>r=rOr1msgrDrDrFrGWs     native_objectr:kwdsUnpack[OnlySeries]cKrBrCrDr[r\rDrDrF from_nativexrLr_Unpack[AllowSeries]cKrBrCrDr^rDrDrFr_zrLr2Unpack[ExcludeSeries]cKrBrCrDr^rDrDrFr_|rHr9Unpack[AllowLazy]cKrBrCrDr^rDrDrFr_rLcKrBrCrDr^rDrDrFr_rHcKrBrCrDr^rDrDrFr_rHcKrBrCrDr^rDrDrFr_rHcKrBrCrDr^rDrDrFr_rHIntoDataFrameT | IntoSeriesT/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]cKrBrCrDr^rDrDrFr_rH-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTUnpack[AllowAny]cKrBrCrDr^rDrDrFr_rHUnpack[PassThroughUnknown]cKrBrCrDr^rDrDrFr_rL eager_only series_only allow_series bool | NonecCrBrCrDr[r=rhrirjrDrDrFr_sr=rhrirjJIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | TOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | Tc Cst|||d||tjdS)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=rheager_or_interchange_onlyrirjversion)_from_native_implrMAINrlrDrDrFr_s+)r=rhcompliant_objectrqrrrcCst|r|r|sd}t||S|j||ddSt|rF|r,|s*d}t||S|s0|r:|s8d}t||S|j||ddSt|rb|sV|sTd}t||S|j | |ddSdS)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`) rrY dataframe__narwhals_dataframe__ _with_versionr lazyframe__narwhals_lazyframe__rseries__narwhals_series__)rur=rhrqrirjrrrZrDrDrF_translate_if_compliantsB rc CsHddlm}ddlm}m} ddlm} t||| fr|s|St|| r*|s(|r*|S|r8|dur6d} t| d}|rB|rBd} t| t |||||||d } durS| St |r|rmt |sm|skd t |j } t| |S|sq|rt|r|s}d } t| |S|st |r|sd } t| |S|j|j|St|rt|r|r|sd t |j } t| |Sn |s|sd } t| |S|j|j|St|rt|r|r|sd t |j } t| |Sn |s|sd } t| |S|j|j|St|rG|r|sd } t| |S|s|r&|s$d} t| |Stjdkr:tdur:d} t| |jtjj|St |ri|sR|r]|s[d} t| |S|j|j|St!|r|st|r|s}d} t| |S|j|j|St"|r|j|} |s|s|r|sd| j#d} t| |S| j|S||rddlm$}|s|r|sd} t| |S|t%j&ur|r|Sd} t| t%j&j'||ddSt(||}|durt |||||||d S|s"dt |} t()t |}r| d|7} t| |S)Nr)supports_dataframe_interchanger-r0FzJInvalid 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.dataframerrQr.r/rRr1rS ValueErrorrrr#rX __qualname__rYr" namespacefrom_native_object compliantr_ to_narwhalsrr!rr%rrDASK_backend_versionr ImportError from_backendrrrimplementationrrV1rzr _show_suggestions)r[r=rhrqrirjrrrr.r/r1rZ translatedns_sparkrruhintrDrDrFrs sJ                               rsobj,Frame | Series[Any] | IntoFrame | IntoSeriescGsF|sd}t|dd|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`.cSsh|]}t|qSrD) _get_native_namespace_single_obj).0xrDrDrF sz'get_native_namespace..rz0Found objects with different native namespaces: rP)rlenpop)rrZresultrDrDrFget_native_namespaces  rcCs$t|r|Stjj|jSrC)r__native_namespace__rrtrrrto_native_namespace)rrDrDrFrsrTfuncCallable[..., Any] | NoneCallable[..., Any]cs(dfdd }|dur|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()) rrrAcs"tdfdd }|S)NargsrkwargsrAcsfdd|D}fdd|D}fddg||RD}t|dkr6d}t||i|}t|d S) Nc sg|] }t|dqSrmr_)rargrjrhr=rirDrF HszBnarwhalify..decorator..wrapper..c s$i|]\}}|t|dqSrr)rnamevaluerrDrF SszBnarwhalify..decorator..wrapper..cs"h|] }t|ddrqS)rN)getattr)rvbrDrFr^s zAnarwhalify..decorator..wrapper..rz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r<)itemsvaluesrrrG)rrbackendsrZr)rjrhrr=rirrFwrapperFs    z.narwhalify..decorator..wrapper)rrrrrArr)rrr)rrF decoratorEs%znarwhalify..decoratorN)rrrArrD)rr=rhrirjrrDrrF narwhalify s8)r scalar_likecCst}|dus t|tr|}|St}r0t||jr0|jdkr0|t}tt j |d}|St |s8t |r>|}|S|rLt||j rL|}|S|rZt||jrZ|}|St|trc|}|St|rkd}|St|ru|}|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. )rrSNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltar r Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar$as_pyrXr)rpdscalarnpmsrZrDrDrF to_py_scalartsF       rcCs&tt}o|jj|o||SrC)rKrapitypes is_scalarisna)rrrDrDrFrs&r)rrrGr)r>r?r=r@rAr4)r>rIr=r@rAr6)r>rJr=r@rAr8)r>rr=rKrAr)r>rMr=rKrArN)r[r:r\r]rAr:)r[r:r\r`rAr:)r[r2r\rarAr2)r[r9r\rbrAr9)r[r4r\rarAr?)r[r8r\r]rArJ)r[r8r\r`rArJ)r[r6r\rbrArI)r[rcr\r`rArd)r[rer\rfrArM)r[r;r\rgrAr;) r[rr=rKrhrKrirKrjrkrAr) r[rnr=rKrhrKrirKrjrkrAro)rurr=rKrhrKrqrKrirKrjrkrrrrAr)r[rr=rKrhrKrqrKrirKrjrkrrrrAr)rrrArrC) rrr=rKrhrKrirKrjrkrAr)rrrAr)rrrArK)\ __future__rdatetimerdecimalr functoolsrtypingrrrr r r narwhalsr narwhals._constantsr rnarwhals._nativerrrrnarwhals._utilsrrrrrrnarwhals.dependenciesrrrrrrrr r!r"r#r$r%typing_extensionsr&narwhals._translater'r(r)r*r+r,rQr.r/rRr1narwhals.typingr2r3r4r5r6r7r8r9r:r;rKbytesstrintfloatcomplexrdatertimerrGr_rrsrrrrr__all__rDrDrDrFs      <   ,  !            92 X   g 8