haSSKJr SSKrSSKJr SSKJr SSKJ r J r J r J r J r Jr SSKJrJr SSKJrJrJrJr SSKJrJrJr SS KJrJrJrJrJ r J!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/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7 \ "S 5r8\9\:\;\<\=\>\4r?\R\R\R4rC\SS.S9Sjj5rD\SS.S:Sjj5rD\SS.S;Sjj5rD\SSj5rE\S?Sj5rE\S@Sj5rE\SS.SASjj5rE\SSSS.SBSjj5rE\SSSS.SCSjj5rE\SSS.SDSjj5rE\SSS.SES jj5rE\SSS!.SFS"jj5rE\SSS#.SGS$jj5rE\SSSSS%.SHS&jj5rE\SSSSS%.SIS'jj5rE\SSSS(.SJS)jj5rE\SSSS*.SKS+jj5rE\SSSS,.SLS-jj5rE\SMS.j5rESSSSS%.SNS/jjrESSSSSS0.SOS1jjrFSPS2jrGSPS3jrHSQS4SSS4S%.SRS5jjjrISSS6jrJSTS7jrK/S8QrLg)U) 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) DataFrameTIntoDataFrameT IntoFrame IntoFrameTIntoLazyFrameT IntoSeries IntoSeriesT LazyFrameTSeriesTT. pass_throughcgNnarwhals_objectr3s eC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\narwhals/translate.py to_nativer:5scgr5r6r7s r9r:r:9sr;cgr5r6r7s r9r:r:=sr;cgr5r6r7s r9r:r:AsCFr;FcSSKJn SSKJn [ X5(aUR R $[ X5(aURR$U(dS[U5S3n[U5eU$)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.dataframer@narwhals.seriesr' isinstance_compliant_frame _native_frame_compliant_seriesnativetype TypeError)r8r3r@r'msgs r9r:r:Esk&-&/--//===/**00777 .tO/D.EQGn r;c gr5r6 native_objectkwdss r9 from_nativerPfsADr;c gr5r6rMs r9rPrPjGJr;c gr5r6rMs r9rPrPnrRr;) series_onlycgr5r6rNr3 eager_onlyrT allow_seriess r9rPrPrs7:r;)rWrTrXcgr5r6rVs r9rPrP}!$r;cgr5r6rVs r9rPrP r;)rTrXcgr5r6rVs r9rPrPrZr;cgr5r6rVs r9rPrPr\r;)rWrTcgr5r6rVs r9rPrPs ORr;)rWrXcgr5r6rVs r9rPrPr;r3rWrTrXcgr5r6rVs r9rPrPrZr;cgr5r6rVs r9rPrPrZr;)r3rTrXcgr5r6rVs r9rPrPrZr;)r3rWrTcgr5r6rVs r9rPrPs58r;)r3rWrXcgr5r6rVs r9rPrPrar;cgr5r6rVs r9rPrPs r;c U(a#S[[U55<3n[U5e[UUUSUU[R S9$)a5Convert `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)r3rWeager_or_interchange_onlyrTrXversion)nextiterrJ_from_native_implrMAIN)rNr3rWrTrXrOrKs r9rPrPsNN A$tDzBRAUVn !"'!  r;)r3rWrjrTrXcSSKJnJnJn 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: )1narwhals._utilsrqrrrsrtrBr$r%rCr'rD ValueErrorrJ dataframe__narwhals_dataframe__ _with_version lazyframe__narwhals_lazyframe__series__narwhals_series__rr rI __qualname__r namespacefrom_native_object compliantrP to_narwhalsrrrr"rrDASK_backend_versionr ImportError from_backendrrrimplementationnarwhals._interchange.dataframeryrV1)rNr3rWrjrTrXrkrqrrrsrtr$r%r'rKns_sparkrys r9rnrn;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`.rxz0Found objects with different native namespaces: rA)r| _get_native_namespace_single_objlenpop)objrKxresults r9get_native_namespacersf0 Mo;> ?3a.q13F ? 6{a@Jo ::< @sA c[U5(aUR5$[RRR U5R R5$r5)r__native_namespace__rrorrrto_native_namespace)rs r9rr?sLC  '')) << ! ! 4 4  n((*+r;Tc:^^^^SUUUU4SjjnUcU$U"U5$)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. 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()) c>>^[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)Nrbrrxz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.r2)rPitemsvaluesgetattrrr|r:)argskwargsargnamevaluevbbackendsrKrrXrWfuncr3rTs r9wrapper.narwhalify..decorator..wrappers   C!-) +!-    &$*<<> $2KDk!-) +!- $2  342&--/22A $:DAAAA2  8}q w o%4*6*FV,? ?E  sB=C&C C)rrrrreturnrr)rrrXrWr3rTs` r9 decoratornarwhalify..decorators) t# @# @ # @Jr;)rCallable[..., Any]rrr6)rr3rWrTrXrs ```` r9 narwhalifyrIs(p''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. )rrDNON_TEMPORAL_SCALAR_TYPESr datetime64dtypeitemrr dt timedeltarr Timestamp to_pydatetime Timedeltato_pytimedeltaTEMPORAL_SCALAR_TYPES _is_pandas_nar!as_pyrIr|) scalar_likepdscalarnpmsrKs r9 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$r5)boolrapitypes is_scalarisna)rrs r9rrs: z|#U)?)?)DUQT VVr;)rrr:r)r8DataFrame[IntoDataFrameT]r3Literal[False]rr))r8zLazyFrame[IntoFrameT]r3rrr+)r8Series[IntoSeriesT]r3rrr.)r8rr3rrr)r8zGDataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | Series[IntoSeriesT]r3rrz/IntoDataFrameT | IntoFrameT | IntoSeriesT | Any)rNr0rOrrr0)rNr(rOrrr()rNr/rOrrr/) rNzIntoDataFrameT | IntoSeriesTr3 Literal[True]rWrrTrrXrrz/DataFrame[IntoDataFrameT] | Series[IntoSeriesT]) rNr)r3rrWrrTrrXNonerr) rNr1r3rrWrrTrrXrrr1) rNr)r3rrWrrTrrXrrr) rNr1r3rrWrrTrrXrrr1) rNz)IntoFrameT | IntoLazyFrameT | IntoSeriesTr3rrWrrTrrXrrzGDataFrame[IntoFrameT] | LazyFrame[IntoLazyFrameT] | Series[IntoSeriesT]) rNr.r3rrWrrTrrXrrr) rNr,r3rrWrrTrrXrrzLazyFrame[IntoLazyFrameT]) rNr)r3rrWrrTrrXrrr) rNr)r3rrWrrTrrXrrr) rNzIntoFrame | IntoSeriesr3rrWrrTrrXrrz-DataFrame[Any] | LazyFrame[Any] | Series[Any]) rNr.r3rrWrrTrrXrrr) rNrr3rrWrrTrrX bool | Nonerr)rNzFIntoLazyFrameT | IntoFrameT | IntoSeriesT | IntoFrame | IntoSeries | Tr3rrWrrTrrXrrOrrzKLazyFrame[IntoLazyFrameT] | DataFrame[IntoFrameT] | Series[IntoSeriesT] | T)rNrr3rrWrrjrrTrrXrrkrrr)rzFDataFrame[Any] | LazyFrame[Any] | Series[Any] | IntoFrame | IntoSeriesrrr5) rzCallable[..., Any] | Noner3rrWrrTrrXrrr)rrrr)rrrr)M __future__rdatetimerdecimalr functoolsrtypingrrr r r r narwhals._constantsr rnarwhals._namespacerrrrr{rrrnarwhals.dependenciesrrrrrrrrrrr r!r"rBr$r%rCr'narwhals.typingr(r)r*r+r,r-r.r/r0r1rbytesstrintfloatcomplexrdatertimerr:rPrnrrrrr__all__r6r;r9rsg"KK4 JI 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 $'!$ !               $ 3Y33 3  3  3 3Q3r&+ $___ _ $ ____ _D PD+ O++'+e $ e #ee e  e  eeP8vW Nr;