hh}`@ddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZddlmZmZddlmZmZmZmZddlmZmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#Z#m$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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7e d Z8e9e:e;eefZ?ej@ejAejBfZCedddbdZDedddcdZDedddddZDededZDd ddfd#ZDedgd'ZEedhd)ZEedid+ZEedd,djd3ZEedddd4dkd6ZEedddd4dld7ZEeddd8dmd9ZEeddd8dnd:ZEeddd;dod=ZEeddd>dpd?ZEeddddd@dqdAZEeddddd@drdBZEeddddCdsdDZEeddddEdtdHZEeddddIdudJZEedvdLZEd d d dd@dwdOZEd d d d ddPdxdTZFdydWZGdydXZH dzdYd d dYd@d{d]ZId|d_ZJd}d`ZKgdaZLdS)~) annotationsN)Decimalwraps) TYPE_CHECKINGAnyCallableLiteralTypeVaroverload)EPOCH MS_PER_SECOND)is_native_arrowis_native_pandas_likeis_native_polarsis_native_spark_like)ImplementationVersionhas_native_namespace) 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) DataFrameTFrameIntoDataFrameT IntoFrameIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughnarwhals_objectDataFrame[IntoDataFrameT]r3Literal[False]returnr*cdSNr4r3s I/var/www/histauto/venv/lib/python3.11/site-packages/narwhals/translate.py to_nativer=5 SLazyFrame[IntoLazyFrameT]r,cdSr9r:r;s r<r=r=9r>r?Series[IntoSeriesT]r.cdSr9r:r;s r<r=r==s #r?rboolcdSr9r:r;s r<r=r=AsCF3r?FKDataFrame[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) BaseFramer&zExpected Narwhals object, got .) narwhals.dataframerInarwhals.seriesr' isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r4r3rIr'msgs r<r=r=Es&-,,,,,&&&&&&/9-->/==/6**8077 GtO/D/DGGGnn r? native_objectr0kwdsc dSr9r:rUrVs r< from_nativerYfsADr?r(c dSr9r:rXs r<rYrYjGJsr?r/c dSr9r:rXs r<rYrYnr[r?) series_onlyIntoDataFrameT | IntoSeriesT Literal[True] eager_onlyr] allow_series/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]cdSr9r:rUr3r`r]ras r<rYrYrs 7:cr?)r`r]raNonecdSr9r:rds r<rYrY} !$r?cdSr9r:rds r<rYrY  r?)r]racdSr9r:rds r<rYrYrgr?cdSr9r:rds r<rYrYrir?)r`r]-IntoDataFrameT | IntoLazyFrameT | IntoSeriesTcdSr9r:rds r<rYrYs SVRUr?)r`racdSr9r:rds r<rYrY #r?r3r`r]racdSr9r:rds r<rYrYrgr?cdSr9r:rds r<rYrYrgr?)r3r]racdSr9r:rds r<rYrYrgr?)r3r`r]IntoFrame | IntoSeries-DataFrame[Any] | LazyFrame[Any] | Series[Any]cdSr9r:rds r<rYrYs 58Cr?)r3r`racdSr9r:rds r<rYrYror? bool | NonecdSr9r:rds r<rYrYs  #r?JIntoLazyFrameT | IntoDataFrameT | IntoSeriesT | IntoFrame | IntoSeries | TOLazyFrame[IntoLazyFrameT] | DataFrame[IntoDataFrameT] | Series[IntoSeriesT] | Tc |r.dtt|}t|t|||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. z1from_native() got an unexpected keyword argument F)r3r`eager_or_interchange_onlyr]raversion)nextiterrS_from_native_implrMAIN)rUr3r`r]rarVrTs r<rYrYsbX V$tDzzBRBRVVnn !"'!    r?)r3r`r}r]rar}r~rc ddlm}ddlm}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|r|r|sd}t||S|s|r|sd}t||StHj%&dkrtOd}tQ||j)tHj%j|StU|r]|s|r|sd}t||S|j|j|StW|r]|s|r|sd}t||S|j|j|StY|rj|j|}|s|s|r|sd|j-d}t||S|j|S||rlddlm.}|s|r|sd}t||S|t^j0ur|r|Sd}t|t^j0||d S|s!dt/|}t||S)Nr)supports_dataframe_interchange)is_compliant_dataframeis_compliant_lazyframeis_compliant_seriesr#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.LazyFramez1Cannot 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. interchangezLExpected pandas-like dataframe, Polars dataframe, or Polars lazyframe, got: )1narwhals._interchange.dataframernarwhals._utilsrrrrKr$r%rLr'rM ValueErrorrS dataframe__narwhals_dataframe__ _with_version lazyframe__narwhals_lazyframe__series__narwhals_series__rr rR __qualname__r namespacefrom_native_object compliantrY to_narwhalsrrrr"rrDASK_backend_versionr ImportError from_backendrrrimplementationrrV1)rUr3r`r}r]rar~rrrrr$r%r'rTns_sparkrs r<rr=scONNNNN 87777777&&&&&&-)Y!788-((k\ 5 ^CS// ! /eoom,,  ! %Dnn$    0 0 2 2 @ @ I IQW!   m,,   ! %Dnn$  !2 ! %bnn$    0 0 2 2 @ @ I IQW!   =))  ! %Lnn$ ~~  - - / / = =g F Ff    &&  !/ >> ! %^D+> ? ? {{=11 []] -((   ! ! %fnn$   0 0 ? ? {{=11 []] ]##   ! ! %`nn$   0 0 ? ? {{=11 []] M** K$77 FF  !* !(A ! %@$3@@@ nn$ !--m<<HHJJJ&%m44ZDDDDDD  ! ! %F nn$ '* $ $ %$$Y C.. z##$4$4]$C$C=#YYY r]abo]p]prrnn r?obj,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|Sr:) _get_native_namespace_single_obj).0xs r< z'get_native_namespace..8s! ? ? ?a.q11 ? ? ?r?rz0Found objects with different native namespaces: rJ)rlenpop)rrTresults r<get_native_namespacersk, Moo ? ?3 ? ? ?F 6{{aJJJJoo ::<<r?ct|r|Stjj|jSr9)r__native_namespace__rrrrrto_native_namespace)rs r<rr?sUC  *''))) < ! 4 4   ((**+r?TfuncCallable[..., 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()) rrr7cHtdfd }|S)Nargsrkwargsr7c2 fd|D} fd|D}fdg||RD}t|dkrd}t||i|}t | S)Nc 8g|]}t|SrprY)rargrar`r3r]s r< zBnarwhalify..decorator..wrapper..sI   !-) +!-    r?c @i|]\}}|t|Srr)rnamevaluerar`r3r]s r< zBnarwhalify..decorator..wrapper..sO    D%k!-) +!-    r?cJh|]}t|ddx S)rN)getattr)rvbs r<rzAnarwhalify..decorator..wrapper..sG $:DAAAAr?rz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r2)itemsvaluesrrr=) rrbackendsrTrrrar`rr3r]s @r<wrapperz.narwhalify..decorator..wrappers           D       $*<<>>   F242&--//22H 8}}q  w oo%T4*6**FV,??? ?r?)rrrrr7rr)rrrar`r3r]s` r< decoratorznarwhalify..decoratorsX t# @# @# @# @# @# @# @# @# @ # @Jr?N)rrr7rr:)rr3r`r]rars ```` r< narwhalifyrIsPp'''''''''R | 9T??r? 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. )rrMNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltarr Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar!as_pyrRr)rpdscalarnpmsrTs r< to_py_scalarrs. Bj6OPP{{  {BM 2 2  !1 1 1     = 026666  % % )D)D!!##  ; 55**,,  ; 55++-- K!6 7 7  { # #  ; ' '""$$ d;>O>O     oo Mr?cttx}o3|jj|o||Sr9)rDrapitypes is_scalarisna)rrs r<rrs@ z||#U)?)?)D)DUQT V VVr?)rrr=r)r4r5r3r6r7r*)r4r@r3r6r7r,)r4rBr3r6r7r.)r4rr3rDr7r)r4rFr3rDr7rG)rUr0rVrr7r0)rUr(rVrr7r()rUr/rVrr7r/) rUr^r3r_r`r_r]r6rar_r7rb) rUr*r3r_r`r6r]r6rarer7r5) rUr1r3r_r`r6r]r6rarer7r1) rUr*r3r_r`r_r]r6rarer7r5) rUr1r3r_r`r_r]r6rarer7r1) rUrlr3r_r`r6r]r6rar_r7rF) rUr.r3r_r`r6r]r_rarer7rB) rUr,r3r6r`r6r]r6rarer7r@) rUr*r3r6r`r6r]r6rarer7r5) rUr*r3r6r`r_r]r6rarer7r5) rUrtr3r6r`r6r]r6rar_r7ru) rUr.r3r6r`r6r]r_rarer7rB) rUrr3rDr`rDr]rDrarxr7r)rUrzr3rDr`rDr]rDrarxrVrr7r{)rUrr3rDr`rDr}rDr]rDrarxr~rr7r)rrr7rr9) rrr3rDr`rDr]rDrarxr7r)rrr7r)rrr7rD)M __future__rdatetimerdecimalr functoolsrtypingrrr r r r narwhals._constantsr rnarwhals._nativerrrrrrrrnarwhals.dependenciesrrrrrrrrrrr r!r"rKr$r%rLr'narwhals.typingr(r)r*r+r,r-r.r/r0r1rDbytesstrintfloatcomplexrdatertimerr=rYrrrrrr__all__r:r?r<rs""""""KKKKKKKKKKKKKKKK44444444 JIIIIIIIII  77777777&&&&&&                       GCLL!5#sE7GL",8 RU  RU  LO  FFF F B DDD D JJJ J JJJ J #& ::::: : "%"% $$$$$ $ "%"%         #& $$$$$ $ #&         "%"% VVVVV V "%   $'!$"% $$$$$ $ $'!$"% $$$$$ $ $'"% $$$$$ $ $'!$"% 88888 8 $'!$    $ $888888|&+ $______D@++++'+d $ ddddddN5555pWWWW N M Mr?