-Phk2ddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$e r$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3e d Z4e5e6e7e8e9e:efZ;ej<ej=ej>fZ?ed ddgdZ@ed ddhdZ@ed ddidZ@edjdZ@ddddkd$Z@edld(ZAedmd*ZAednd,ZAed d-dod4ZAed d d d5dpd7ZAed d d d5dqd8ZAed d d9drd:ZAed d d9dsd;ZAed d d<dtd?ZAed d d@dudAZAed d d d dBdvdEZAed d d d dBdwdFZAed d d dGdxdHZAed d d dIdydLZAed d d dMdzdNZAed{dOZAdddPdPddQd|dTZAdPdPdPdPddUd}dYZBd~d\ZCd~d]ZD ddddPdPd^dQddbZEdddZFddeZGgdfZHdS)) annotationsN)Decimalwraps) TYPE_CHECKINGAnyCallableLiteralTypeVaroverload)is_native_arrowis_native_pandas_likeis_native_polarsis_native_spark_like)Version)get_dask 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 DataFrame LazyFrameSeries) DataFrameTIntoDataFrameT IntoFrame IntoFrameTIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughnarwhals_objectDataFrame[IntoDataFrameT]r0Literal[False]returnr&cdSNr1r0s R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/narwhals/translate.py to_nativer:5s SLazyFrame[IntoFrameT]r(cdSr6r7r8s r9r:r:9s r;Series[IntoSeriesT]r+cdSr6r7r8s r9r:r:=s #r;rboolcdSr6r7r8s r9r:r:AsCF3r;)strictr0GDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]rB bool | None/IntoDataFrameT | IntoFrameT | IntoSeriesT | Anycddlm}ddlm}ddlm}|||dd}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. rvalidate_strict_and_pass_though) BaseFramer#FTpass_through_defaultemit_deprecation_warningzExpected Narwhals object, got .) narwhals._utilsrHnarwhals.dataframerInarwhals.seriesr$ isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r1rBr0rHrIr$msgs r9r:r:Es<@?????,,,,,,&&&&&&22 5SWL/9-->/==/6**8077 GtO/D/DGGGnn r; native_objectr-kwdsc dSr6r7rYrZs r9 from_nativer]vsADr;r%c dSr6r7r\s r9r]r]zGJsr;r,c dSr6r7r\s r9r]r]~r_r;) series_onlyIntoDataFrameT | IntoSeriesT Literal[True] eager_onlyra allow_series/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]cdSr6r7rYr0rdrares r9r]r]s 7:cr;)rdrareNonecdSr6r7rhs r9r]r] !$r;cdSr6r7rhs r9r]r]  r;)rarecdSr6r7rhs r9r]r]rkr;cdSr6r7rhs r9r]r]rmr;)rdra)IntoFrameT | IntoLazyFrameT | IntoSeriesTGDataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]cdSr6r7rhs r9r]r]s ORcr;)rdrecdSr6r7rhs r9r]r] #r;r0rdrarer)LazyFrame[IntoLazyFrameT]cdSr6r7rhs r9r]r]rkr;cdSr6r7rhs r9r]r]rkr;)r0rarecdSr6r7rhs r9r]r]rkr;)r0rdraIntoFrame | IntoSeries-DataFrame[Any] | LazyFrame[Any] | Series[Any]cdSr6r7rhs r9r]r]s 58Cr;)r0rdrecdSr6r7rhs r9r]r]rtr;cdSr6r7rhs r9r]r] s  #r;F)rBr0rdrareFIntoLazyFrameT | IntoFrameT | IntoSeriesT | IntoFrame | IntoSeries | TKLazyFrame[IntoLazyFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | Tc ddlm}|||dd}|r.dtt|}t |t |||d||t jS)aqConvert `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. rrGFTrJz1from_native() got an unexpected keyword argument )r0rdeager_or_interchange_onlyrareversion)rNrHnextiterrW_from_native_implrMAIN) rYrBr0rdrarerZrHrXs r9r]r]sd@?????22 5SWL V$tDzzBRBRVVnn !"'!    r;)r0rdrrarerrrc ddlm}m}m} m} m} ddlm} m} ddl m }t|| | fr|s|St||r|s|r|S|r|durd}t|d}|r|rd}t|||rS|r|sd }t||S|||d S| |rl|r|sd }t||S|s|r|sd }t||S|||d S| |rS|s|sd}t||S|||d St+|r|r9t-|s*|s&dt/|j}t||S|s|r$t3|r|sd}t||S|s$t-|r|sd}t||S|j|j|St?|rtA|r-|r*|s&dt/|j}t||Sn|s|sd}t||S|j|j|StC|rtE|r-|r*|s&dt/|j}t||Sn|s|sd}t||S|j|j|StG|rddl$m%}|r|sd}t||S|s|r|sd}t||S| tM}|dkrtOd}tQ|||||StS|r]|s|r|sd}t||S|j|j|StU|r]|s|r|sd}t||S|j|j|StW|rj|j|}|s|s|r|sd|j,d}t||S|j|S||rlddl-m.}|s|r|sd}t||S|t^j0ur|r|Sd}t|t^j0||d S|s!dt/|}t||S) Nr)_supports_dataframe_interchangeis_compliant_dataframeis_compliant_lazyframeis_compliant_series parse_versionr r#FzJInvalid 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`z#Cannot only use `series_only` with zQCannot only use `eager_only` or `eager_or_interchange_only` with polars.LazyFrame) DaskNamespacez1Cannot only use `series_only` with dask DataFramezOCannot only use `eager_only` or `eager_or_interchange_only` with dask DataFrame)i zPlease install dask-expr)backend_versionrzNCannot 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. interchangezLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )1rNrrrrrrOr!r"rPr$rQ ValueErrorrW dataframe__narwhals_dataframe__ _with_version lazyframe__narwhals_lazyframe__series__narwhals_series__rrrV __qualname__r namespacefrom_native_object compliantr] to_narwhalsrrr rrnarwhals._dask.namespacerrr ImportErrorrrrimplementationnarwhals._interchange.dataframerrV1)rYr0rdrrarerrrrrrr!r"r$rXr dask_versionns_sparkrs r9rr[sv87777777&&&&&&-)Y!788-((k\ 5 ^CS// ! /eoom,,z  ! %Dnn$    0 0 2 2 @ @ I IQW!     . .q  ! %Dnn$  !2 ! %bnn$    0 0 2 2 @ @ I IQW!     ] + +c ! %Lnn$ ~~  - - / / = =g F Ff   - ( (X  !/ >> ! %^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`.c,h|]}t|Sr7) _get_native_namespace_single_obj).0xs r9 z'get_native_namespace..Ys! ? ? ?a.q11 ? ? ?r;rz0Found objects with different native namespaces: rM)rlenpop)rrXresults r9get_native_namespacer>sk0 Moo ? ?3 ? ? ?F 6{{aJJJJoo ::<<r;clddlm}ddlm}|tt 5t jj |j cdddS#1swxYwY||r| Sdt|}t |)Nr)suppress)has_native_namespacez4Could not get native namespace from object of type: ) contextlibrrNrrWAssertionErrorrrrrrto_native_namespace__native_namespace__rV)rrrrXs r9rr`s$#####444444 )^ , ,//|%88   ,,..//////////////// C  *''))) Lc L LC C..s;A++A/2A/TfuncCallable[..., Any] | NoneCallable[..., Any]cdddlm}||ddd fd }||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: Determine what happens if the object can't be converted to Narwhals *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/). - `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()) rrGTrJrrr4cHtdfd }|S)Nargsrkwargsr4c2 fd|D} fd|D}fdg||RD}t|dkrd}t||i|}t | S)Nc 8g|]}t|Srur])rargrerdr0ras r9 zBnarwhalify..decorator..wrapper..sI   !-) +!-    r;c @i|]\}}|t|Srr)rnamevaluererdr0ras r9 zBnarwhalify..decorator..wrapper..sO    D%k!-) +!-    r;cJh|]}t|ddx S)rN)getattr)rvbs r9rzAnarwhalify..decorator..wrapper..sG $:DAAAAr;rz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r/)itemsvaluesrrr:) rrbackendsrXrrrerdrr0ras @r9wrapperz.narwhalify..decorator..wrappers           D       $*<<>>   F242&--//22H 8}}q  w oo%T4*6**FV,??? ?r;)rrrrr4rr)rrrerdr0ras` r9 decoratorznarwhalify..decoratorsX t# @# @# @# @# @# @# @# @# @ # @Jr;N)rrr4r)rNrH)rrBr0rdrarerHrs ```` r9 narwhalifyrrsD@?????22 4RVL'''''''''R |yr; scalar_likec:t}|t|tr|}nqtx}rdt||jrO|jdkrD|dz}tjdddtj |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) 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]iir) microsecondsz/Expected object convertible to a scalar, found z. )rrQNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemdtdatetime timedeltarr Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_naras_pyrVr)rpdscalarnpmsrXs r9 to_py_scalarrs4 Bj6OPP{{  {BM 2 2  !1 1 1     4 'T1a((2O>O     oo Mr;cttx}o3|jj|o||Sr6)r@rapitypes is_scalarisna)rrs r9rr%s@ z||#U)?)?)D)DUQT V VVr;)rrr:r)r1r2r0r3r4r&)r1r<r0r3r4r()r1r>r0r3r4r+)r1rr0r@r4r)r1rCrBrDr0rDr4rE)rYr-rZrr4r-)rYr%rZrr4r%)rYr,rZrr4r,) rYrbr0rcrdrcrar3rercr4rf) rYr&r0rcrdr3rar3rerir4r2) rYr.r0rcrdr3rar3rerir4r.) rYr&r0rcrdrcrar3rerir4r2) rYr.r0rcrdrcrar3rerir4r.) rYrpr0rcrdr3rar3rercr4rq) rYr+r0rcrdr3rarcrerir4r>) rYr)r0r3rdr3rar3rerir4rv) rYr&r0r3rdr3rar3rerir4r2) rYr&r0r3rdrcrar3rerir4r2) rYrzr0r3rdr3rar3rercr4r{) rYr+r0r3rdr3rarcrerir4r>) rYrr0r@rdr@rar@rerDr4r)rYrrBrDr0rDrdr@rar@rerDrZrr4r)rYrr0r@rdr@rr@rar@rerDrrr4r)rrr4rr6)rrrBrDr0rDrdr@rar@rerDr4r)rrr4r)rrr4r@)I __future__rrrdecimalr functoolsrtypingrrr r r r narwhals._namespacer rrrrNrnarwhals.dependenciesrrrrrrrrrrrrrrrOr!r"rPr$narwhals.typingr%r&r'r(r)r*r+r,r-r.r@bytesstrintfloatcomplexrdatertimerr:r]rrrrrr__all__r7r;r9rs""""""KKKKKKKKKKKKKKKK $#####" 77777777&&&&&&                       GCLL!5#sE7GL",8 RU  NQ  LO  FFF F $ ......b DDD D JJJ J JJJ J #& ::::: : "%"% $$$$$ $ "%"%         #& $$$$$ $ #&         "%"% RRRRR R "%   $'!$"% $$$$$ $ $'!$"% $$$$$ $ $'"% $$$$$ $ $'!$"% 88888 8 $'!$     $ $CCCCCCR&+ $``````FD&'+u $ $uuuuuup8888vWWWW N M Mr;