o h@sddlmZddlmZddlmZddlmZddlmZddlm 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,dd'l+m-Z-e r5dd(l.m/Z/dd)l.m0Z0dd*l1m2Z2dd+l3m4Z4dd,l3m5Z5dd-l3m6Z6dd.l3m7Z7dd/l3m8Z8dd0l3m9Z9dd1l3m:Z:dd2l3m;Z;dd3l3me?e@eAeBeCefZDed5d6dd=d>ZEed5d6ddAd>ZEed5d6ddDd>ZEeddGd>ZEdHdHdIddNd>ZEeddRdSZFeddUdSZFeddWdSZFed5dXdd_dSZFed5d5d5d`ddbdSZFed5d5d5d`ddcdSZFed5d5ddddedSZFed5d5ddddfdSZFed5d5dgddjdSZFed5d5dkddldSZFed5d5d5d5dmddpdSZFed5d5d5d5dmddqdSZFed5d5d5drddsdSZFed5d5d5dtddwdSZFed5d5d5dxddydSZFeddzdSZFdHdHd{d{dHd|dddSZFd{d{d{d{dHddddZGdddZHdddZI HddHdHd{d{dd|dddZJdddZKgdZLdHS)) 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)import_namespace DataFrame LazyFrameSeries) DataFrameT)IntoDataFrameT) IntoFrame) IntoFrameT)IntoLazyFrameT) IntoSeries) IntoSeriesT) LazyFrameT)SeriesTT. pass_throughnarwhals_objectDataFrame[IntoDataFrameT]r;Literal[False]returnr1cCdSNr<r;rBrBF/var/www/vscode/kcb/lib/python3.10/site-packages/narwhals/translate.py to_nativeFrELazyFrame[IntoFrameT]r3cCr@rArBrCrBrBrDrEJrFSeries[IntoSeriesT]r6cCr@rArBrCrBrBrDrENrFr boolcCr@rArBrCrBrBrDrERN)strictr;GDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]rK bool | None/IntoDataFrameT | IntoFrameT | IntoSeriesT | AnycCsxddlm}ddlm}ddlm}|||ddd}t||r#|jjSt||r,|j j S|s:dt |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.dataframerOnarwhals.seriesr/narwhals.utilsrQ isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r<rKr;rOr/rQmsgrBrBrDrEVs      native_objectr8kwdscKr@rArBrarbrBrBrD from_nativerJrdr0cKr@rArBrcrBrBrDrdrJr7cKr@rArBrcrBrBrDrdrJ) series_onlyIntoDataFrameT | IntoSeriesT Literal[True] eager_onlyre allow_series/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]cCr@rArBrar;rhrerirBrBrDrd)rhreriNonecCr@rArBrkrBrBrDrdrlcCr@rArBrkrBrBrDrdrl)rericCr@rArBrkrBrBrDrdrlcCr@rArBrkrBrBrDrdrl)rhre)IntoFrameT | IntoLazyFrameT | IntoSeriesTGDataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]cCr@rArBrkrBrBrDrdrl)rhricCr@rArBrkrBrBrDrdrlr;rhrerir4LazyFrame[IntoLazyFrameT]cCr@rArBrkrBrBrDrdrlcCr@rArBrkrBrBrDrdrl)r;rericCr@rArBrkrBrBrDrdrl)r;rhreIntoFrame | IntoSeries-DataFrame[Any] | LazyFrame[Any] | Series[Any]cCr@rArBrkrBrBrDrdrl)r;rhricCr@rArBrkrBrBrDrdrlcCr@rArBrkrBrBrDrdrlF)rKr;rhreriFIntoLazyFrameT | IntoFrameT | IntoSeriesT | IntoFrame | IntoSeries | TKLazyFrame[IntoLazyFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | Tc KsRddlm}|||ddd}|rdtt|}t|t|||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__` 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. rrPFTrRz1from_native() got an unexpected keyword argument )r;rheager_or_interchange_onlyreriversion)rXrQnextiterr__from_native_implr(MAIN) rarKr;rhrerirbrQr`rBrBrDrd%s 1)r;rhrvrerirvrwr(c$CsTddlm}ddlm}ddlm} ddlm} ddlm} ddlm} ddlm } dd lm }dd lm }t |||frA|sA|St || rL|sJ|rL|S|rZ|d urXd }t |d }|rd|rdd}t || |r||rt|srd}t||S||ddS| |r|r|sd}t||S|s|r|sd}t||S||ddS||r|s|sd}t||S| |ddSt|r)ddlm}|rt|s|sdt|j}t||S|s|rt|r|sd}t||S|st|r|sd}t||S|t}|||d}||}| |r||ddS| |r#||ddS| |ddSt|rUddlm}|rB|s@d}t||St}|||||| j|d dddSt |rddl!m"}|sn|sld}t||St}| ||| j|||dddSt#|rddlm}t$}|r|sd}t||S|||| j%|||d dddSt&|rddl!m"}t$}|s|sd}t||S| ||| j%|||dddSt'|rddlm}t(}|r|sd }t||S|||| j)|||d dddSt*|r.ddl!m"}t(}|s|sd}t||S| ||| j)|||dddSt+|r{|rLt,|rL|sJdt|j}t||S|s_t,|s_|s]d}t||St-|.|j/|}| |ru||ddS| |ddSt0|rdd!l1m2}|r|sd"}t||S|s|r|sd#}t||S|t3}|d$krt4durd%}t5||||d}|||ddSt6|r|s|r|sd&}t||St-|.|j/|}|t7j8ur||d'dS||ddSt9|r=dd(l:m;}|s|r|sd)}t||Sddl<} || }!|t7j8ur2||||!|dd'dS||||!|dddSt=|rtt-|.|}"|rXd|"j>j?d*}t||s^|rjd+|"j>j?d*}t|||"j/|ddS| |rdd,l@mA}#|s|r|sd-}t||S||#||d.d'dS|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_versionrwlazy)PandasLikeDataFrame)rimplementationrwvalidate_column_names)PandasLikeSeries)rrrwz2Cannot only use `series_only` with modin.DataFrame)rrrwrz1Cannot 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__)rwzLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )BrVr+r-rWr/rXr|r}r~rrrrY ValueErrorr___narwhals_dataframe____narwhals_lazyframe____narwhals_series__rnarwhals._polars.namespacerr%r^ __qualname__r$rrdr!narwhals._pandas_like.dataframerrPANDASr"narwhals._pandas_like.seriesrrrMODINr rrCUDFrrr'r)from_native_object compliantrnarwhals._dask.namespacerrr ImportErrorrr(V1rnarwhals._ibis.dataframeribisrr_aliasnarwhals._interchange.dataframer)$rar;rhrvrerirwr+r-r/r|r}r~rrrr`r pl_versionpl_ns pl_compliantrpdrmpdcudf pa_compliantr dask_versiondd_nsduckdb_compliantrrrns_sparkrrBrBrDrzjs:                                                    rzobjFDataFrame[Any] | LazyFrame[Any] | 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|qSrB) _get_native_namespace_single_obj).0xrBrBrD sz'get_native_namespace..rz0Found objects with different native namespaces: rU)rlenpop)rr`resultrBrBrDget_native_namespaces  rcCsddlm}||r|St|st|rtSt|s!t|r$tSt |s,t |r/t St |s7t |r:tSt|rAtSt|sMt|sMt|rPtSdt|}t|)Nr)has_native_namespacez4Could not get native namespace from object of type: )rXr__native_namespace__r!r"rrr rr'r&rrrrrrr#r$r%rr^r_)rrr`rBrBrDrs" rTfuncCallable[..., Any] | NoneCallable[..., Any]csDddlm}||dddd fdd }|d ur|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()) rrPTrRrrr?cs"tdfdd }|S)Nargsr kwargsr?csfdd|D}fdd|D}fddg||RD}t|dkr6d}t||i|}t|d S) Nc sg|] }t|dqSrprd)rargrirhr;rerBrD BszBnarwhalify..decorator..wrapper..c s$i|]\}}|t|dqSrr)rnamevaluerrBrD MszBnarwhalify..decorator..wrapper..cs"h|] }t|ddrqS)rN)getattr)rvbrBrDrXs zAnarwhalify..decorator..wrapper..rz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r:)itemsvaluesrrrE)rrbackendsr`r)rirhrr;rerrDwrapper@s    z.narwhalify..decorator..wrapper)rr rr r?r r)rrr)rrD decorator?s%znarwhalify..decoratorN)rrr?r)rXrQ)rrKr;rhrerirQrrBrrD narwhalifys A)r scalar_likecCsZ|durdSt|tr |St}|r,t||jr,|jdkr,tdddt|ddS|r<||r>> 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)rYNON_TEMPORAL_SCALAR_TYPESr datetime64dtyperrrisscalarhasattrr Timestamp to_pydatetime Timedeltato_pytimedeltaapitypes is_scalarisna ExceptionrScalaras_pyrndarraysizer^r)rnpris_napacupyr`rBrBrD to_py_scalarosR      r)rrrEr)r<r=r;r>r?r1)r<rGr;r>r?r3)r<rHr;r>r?r6)r<r r;rIr?r )r<rLrKrMr;rMr?rN)rar8rbr r?r8)rar0rbr r?r0)rar7rbr r?r7) rarfr;rgrhrgrer>rirgr?rj) rar1r;rgrhr>rer>rirmr?r=) rar9r;rgrhr>rer>rirmr?r9) rar1r;rgrhrgrer>rirmr?r=) rar9r;rgrhrgrer>rirmr?r9) rarnr;rgrhr>rer>rirgr?ro) rar6r;rgrhr>rergrirmr?rH) rar4r;r>rhr>rer>rirmr?rq) rar1r;r>rhr>rer>rirmr?r=) rar1r;r>rhrgrer>rirmr?r=) rarrr;r>rhr>rer>rirgr?rs) rar6r;r>rhr>rergrirmr?rH) rar r;rIrhrIrerIrirMr?r )rartrKrMr;rMrhrIrerIrirMrbr r?ru)rar r;rIrhrIrvrIrerIrirMrwr(r?r )rrr?r rA)rrrKrMr;rMrhrIrerIrirMr?r)rr r?r )M __future__rrrdecimalr functoolsrtypingrr r r r r narwhals._namespacerrrnarwhals.dependenciesrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'rXr(r)rVr+r-rWr/narwhals.typingr0r1r2r3r4r5r6r7r8r9rIbytesstrintfloatcomplexrrErdrzrrrr__all__rBrBrBrDsJ                                                    0                H W " w M