phjSSKJr SSKrSSKJr SSKJr SSKJ r J r J r J r J r Jr SSKJrJr SSKJrJrJrJr SSKJrJr SS KJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r' \ (a$SS K(J)r)J*r* SS K+J,r, SS K-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 \ "S 5r7\8\9\:\;\<\=\4r>\R~\R\R4rB\SS.S;Sjj5rC\SS.SSj5rCSSS.S?SjjrC\S@Sj5rD\SASj5rD\SBSj5rD\SS.SCSjj5rD\SSSS.SDSjj5rD\SSSS.SESjj5rD\SSS.SFSjj5rD\SSS.SGS jj5rD\SSS!.SHS"jj5rD\SSS#.SIS$jj5rD\SSSSS%.SJS&jj5rD\SSSSS%.SKS'jj5rD\SSSS(.SLS)jj5rD\SSSS*.SMS+jj5rD\SSSS,.SNS-jj5rD\SOS.j5rDSSS/S/SS0.SPS1jjrDS/S/S/S/SS2.SQS3jjrESRS4jrFSRS5jrGSSSSS/S/S6S0.STS7jjjrHSUS8jrISVS9jrJ/S:QrKg)W) annotationsN)Decimalwraps) TYPE_CHECKINGAnyCallableLiteralTypeVaroverload)EPOCH MS_PER_SECOND)is_native_arrowis_native_pandas_likeis_native_polarsis_native_spark_like)ImplementationVersion) 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_throughcgNnarwhals_objectr2s jC:\Users\julio\OneDrive\Documentos\Trabajo\IdeasFrscas\Cabanna\env\Lib\site-packages\narwhals/translate.py to_nativer95scgr4r5r6s r8r9r99sr:cgr4r5r6s r8r9r9=sr:cgr4r5r6s r8r9r9AsCFr:)strictr2cSSKJn SSKJn SSKJn U"XSSS9n[ X5(aURR$[ X5(aURR$U(dS[U5S 3n[U5eU$) aConvert 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._utilsrAnarwhals.dataframerBnarwhals.seriesr& isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r7r>r2rArBr&msgs r8r9r9Es<@,&25SWL/--//===/**00777 .tO/D.EQGn r:c gr4r5 native_objectkwdss r8 from_nativerVvsADr:c gr4r5rSs r8rVrVzGJr:c gr4r5rSs r8rVrV~rXr:) series_onlycgr4r5rTr2 eager_onlyrZ allow_seriess r8rVrVs7:r:)r]rZr^cgr4r5r\s r8rVrV!$r:cgr4r5r\s r8rVrV r:)rZr^cgr4r5r\s r8rVrVr`r:cgr4r5r\s r8rVrVrbr:)r]rZcgr4r5r\s r8rVrVs ORr:)r]r^cgr4r5r\s r8rVrVr:r2r]rZr^cgr4r5r\s r8rVrVr`r:cgr4r5r\s r8rVrVr`r:)r2rZr^cgr4r5r\s r8rVrVr`r:)r2r]rZcgr4r5r\s r8rVrVs58r:)r2r]r^cgr4r5r\s r8rVrVrgr:cgr4r5r\s r8rVrV s r:F)r>r2r]rZr^c SSKJn U"XSSS9nU(a#S[[U55<3n[ U5e[ UUUSUU[ RS9$)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. rr@FTrCz1from_native() got an unexpected keyword argument )r2r]eager_or_interchange_onlyrZr^version)rGrAnextiterrP_from_native_implrMAIN) rTr>r2r]rZr^rUrArQs r8rVrVsfd@25SWL A$tDzBRAUVn !"'!  r:)r2r]rprZr^cSSKJnJnJn Jn SSKJn Jn SSKJ n [X U 45(a U(dU$[X 5(aU(dU(aU$U(aUSLa Sn[U5eSnU(aU(a Sn[U5eU"U5(aJU(aU(d S n[U5eU$URUR5RU5S S 9$U "U5(anU(aU(d S n[U5eU$U(dU(aU(d S n[U5eU$UR!UR#5RU5S S 9$U "U5(aJU(dU(d Sn[U5eU$UR%UR'5RU5S S 9$[)U5(aU(a<[+U5(d,U(d#S[-U5R.3n[U5eU$U(dU(a&[1U5(aU(d Sn[U5eU$U(d&[+U5(aU(d Sn[U5eU$UR2R5U5R6R9U5R;5$[=U5(a[?U5(a4U(a,U(d#S[-U5R.3n[U5eU$OU(dU(d Sn[U5eU$UR2R5U5R6R9U5R;5$[AU5(a[CU5(a4U(a,U(d#S[-U5R.3n[U5eU$OU(dU(d Sn[U5eU$UR2R5U5R6R9U5R;5$[EU5(aU(aU(d Sn[U5eU$U(dU(aU(d Sn[U5eU$[FRHRK5S::a[M5c Sn[OU5eUR2RQ[FRH5R6R9U5R;5$[SU5(afU(dU(aU(d Sn[U5eU$UR2R5U5R6R9U5R;5$[UU5(afU(dU(aU(d Sn[U5eU$UR2R5U5R6R9U5R;5$[WU5(a}UR2R5U5nU(dU(dU(a$U(dSURXS3n[U5eU$UR6R9U5R;5$U"U5(awSSK-J.n U(dU(aU(d Sn[U5eU$U[^R`LaU(aU$Sn[U5e[^R`RU"U5SS 9$U(dS[-U53n[U5eU$)Nr)_supports_dataframe_interchangeis_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: )1rGrwrxryrzrHr#r$rIr&rJ ValueErrorrP dataframe__narwhals_dataframe__ _with_version lazyframe__narwhals_lazyframe__series__narwhals_series__rrrO __qualname__r namespacefrom_native_object compliantrV to_narwhalsrrrr!rrDASK_backend_versionr ImportError from_backendrrrimplementationnarwhals._interchange.dataframerrV1)rTr2r]rprZr^rqrwrxryrzr#r$r&rQns_sparkrs r8rtrt[s 8&-Y!788-((k\ 5 ^CS/ ! /eom,, Dn$    0 0 2 @ @ IQW!   . . Dn$ 2bn$    0 0 2 @ @ IQW!   ] + +Ln$ ~~  - - / = =g Ff  - ( ( / >>;D+>+> ? Y{{=1 []  M * * fn$    0 0 ? Y{{=1 []  } % % `n$    0 0 ? Y{{=1 []  m , ,$$77 F *(A$334J@ n$ !!--m<HHJJ ) 7 7D F n$ '** $$$Y C. zz##$4]$C=#YY \]abo]p\qrn r:cU(d Sn[U5eUVs1sHn[U5iM nn[U5S:waSUS3n[U5eUR5$s snf)a[Get 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`.r~z0Found objects with different native namespaces: rF)r _get_native_namespace_single_objlenpop)objrQxresults r8get_native_namespacer=sf0 Mo;> ?3a.q13F ? 6{a@Jo ::< @sA c`SSKJn SSKJn U"[[ 5 [ RRRU5RR5sSSS5 $!,(df  O=fU"U5(aUR5$S[U53n[ U5e)Nr)suppress)has_native_namespacez4Could not get native namespace from object of type: ) contextlibrrGrrPAssertionErrorrrurrrto_native_namespace__native_namespace__rO)rrrrQs r8rr_s$4 )^ ,||%%88  .,,. - , , C  '')) @c LC C.s AA)) A7TcX^^^^SSKJn U"UTSSS9mSUUUU4SjjnUcU$U"U5$)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. 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()) rr@TrCc>>^[T5SUUUUU4Sjj5nU$)Nc >UVs/sHn[UT T TT S9PM nnUR5VVs0sHup4U[UT T TT S9_M nnn/UQUR5Q7Vs1sH n[USS5=n(dMU"5iM" nn[ U5S:a Sn[ U5eT "U0UD6n [ U T S9$s snfs snnfs snf)Nrhrr~z_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r1)rVitemsvaluesgetattrrrr9)argskwargsargnamevaluevbbackendsrQrr^r]funcr2rZs r8wrapper.narwhalify..decorator..wrappers   C!-) +!-    &$*<<> $2KDk!-) +!- $2  342&--/22A $:DAAAA2  8}q w o%4*6*FV,? ?E  sB=C&C C)rrrrreturnrr)rrr^r]r2rZs` r8 decoratornarwhalify..decorators) t# @# @ # @Jr:)rCallable[..., Any]rr)rGrA)rr>r2r]rZr^rArs ```` r8 narwhalifyrqsBD@2 4RVL''R |r:c4[5nUb[U[5(aUnU$[5=n(a^[XR5(aDUR S:Xa4UR 5[-n[[R"US9-nU$[U5(d[U5(aUR 5nU$U(a,[XR5(aUR5nU$U(a,[XR5(aUR!5nU$[U["5(aUnU$[%U5(aSnU$['U5(aUR)5nU$S[+U5SU<3n[-U5e)a)If 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]) microsecondsz/Expected object convertible to a scalar, found z. )rrJNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltarr Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar as_pyrOr) scalar_likepdscalarnpmsrQs r8 to_py_scalarrs4 Bj6OPP8 M5{   {MM 2 2   !1 1    = 0266* M)  % % )D)D!!#& M% ; 55**," M! ; 55++- M K!6 7 7 M { # # M ; ' '""$ M >d;>O=PPSo  or:c[[5=n=(a= URRR U5=(a UR U55$r4)boolrapitypes is_scalarisna)rrs r8rr$s: z|#U)?)?)DUQT VVr:)rrr9r)r7DataFrame[IntoDataFrameT]r2Literal[False]rr()r7zLazyFrame[IntoFrameT]r2rrr*)r7Series[IntoSeriesT]r2rrr-)r7rr2rrr)r7zGDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]r> bool | Noner2rrz/IntoDataFrameT | IntoFrameT | IntoSeriesT | Any)rTr/rUrrr/)rTr'rUrrr')rTr.rUrrr.) rTzIntoDataFrameT | IntoSeriesTr2 Literal[True]r]rrZrr^rrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]) rTr(r2rr]rrZrr^Nonerr) rTr0r2rr]rrZrr^rrr0) rTr(r2rr]rrZrr^rrr) rTr0r2rr]rrZrr^rrr0) rTz)IntoFrameT | IntoLazyFrameT | IntoSeriesTr2rr]rrZrr^rrzGDataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]) rTr-r2rr]rrZrr^rrr) rTr+r2rr]rrZrr^rrzLazyFrame[IntoLazyFrameT]) rTr(r2rr]rrZrr^rrr) rTr(r2rr]rrZrr^rrr) rTzIntoFrame | IntoSeriesr2rr]rrZrr^rrz-DataFrame[Any] | LazyFrame[Any] | Series[Any]) rTr-r2rr]rrZrr^rrr) rTrr2rr]rrZrr^rrr)rTzFIntoLazyFrameT | IntoFrameT | IntoSeriesT | IntoFrame | IntoSeries | Tr>rr2rr]rrZrr^rrUrrzKLazyFrame[IntoLazyFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T)rTrr2rr]rrprrZrr^rrqrrr)rzFDataFrame[Any] | LazyFrame[Any] | Series[Any] | IntoFrame | IntoSeriesrrr4)rzCallable[..., Any] | Noner>rr2rr]rrZrr^rrr)rrrr)rrrr)L __future__rdatetimerdecimalr functoolsrtypingrrr r r r narwhals._constantsr rnarwhals._namespacerrrrrGrrnarwhals.dependenciesrrrrrrrrrrrr r!rHr#r$rIr&narwhals.typingr'r(r)r*r+r,r-r.r/r0rbytesstrintfloatcomplexrdatertimerr9rVrtrrrrr__all__r5r:r8rs"KK4 4 7&    CL!5#sE7GL",,8 RU.AO  NQ*=K  LO(;I  F F $ ..  .  .5.b D D J J J J #& :/: : :  :  :5: : "%"% $!$ $ $  $  $$ $ "%"%               #& $!$ $ $  $  $$ $ #&               "%"% R<R R R  R  RMR R "%         $'!$"% $!$!$ $  $  $$ $ $'!$"% $!$!$ $  $  $$ $ $'"% $!$!$ $  $  $$ $ $'!$"% 8)8!8 8  8  838 8 $'!$ !               $ $CYC C C  C  CC CQCR&+ $___ _ $ ____ _D PD O&'+u $ $u #u u u  u  uuup8vW Nr: