L iHddlmZddlmZddlmZddlmZmZm Z m Z m Z m Z ddl mZmZmZmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+dd l,m-Z-erPdd l.m/Z/dd l0m1Z1m2Z2ddlmZm3Z3ddl4m5Z5ddlmZm6Z6m7Z7ddl8m9Z9ddl:m;Z;ddl$mZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGgdZHGdde ZIGddee eefZJGddeJeefe eefZKGddeKeefe eefZLGddeLee!fe ee!fZMGd d!eKee#fe ee#fZNGd"d#e%ee eZOGd$d%eOe e e ZPGd&d'eOe"e e"ZQGd(d)ePe ee e e ZRGd*d+ePe ee e e ZSGd,d-ePe ee e e ZTGd.d/eOeeee eZUGd0d1ePe eUe e e ZVGd2d3eQe"eUe"e e"ZWGd4d5ePe ee e e ZXGd6d7ePe ee e e ZYy8)9) annotations)partial) methodcaller) TYPE_CHECKINGAnyCallableGenericLiteralProtocol) CatNamespaceDateTimeNamespace ListNamespace NameNamespaceStringNamespaceStructNamespace)CompliantColumn)CompliantNamespace) AliasName AliasNamesCompliantExprT_coCompliantFrameTCompliantLazyFrameTCompliantSeriesOrNativeExprT_coEagerDataFrameT EagerExprT EagerSeriesT LazyExprT NativeExprT)_StoresCompliantnot_implementedqualified_type_name zip_strict)is_numpy_arrayis_numpy_scalar)MultiOutputExpressionError)Sequence)SelfTypeIs)rEagerNamespace)CompliantSeries)r EvalNames EvalSeries) ExprMetadata) NoDefault)ImplementationVersion_LimitedContext)ClosedIntervalFillNullStrategy IntoDTypeModeKeepStrategyNonNestedLiteral RankMethodRollingInterpolationMethodTimeUnit) CompliantExprDepthTrackingExpr EagerExprLazyExpr NativeExprcHeZdZdZd dZd dZd dZd dZd dZd dZ d dZ y ) r>a An `Expr`-like object from a package with [Lazy-only support](https://narwhals-dev.github.io/narwhals/extending/#levels-of-support). Protocol members are chosen *purely* for matching statically - as they are common to all currently supported packages. cyN)selfargskwdss ^/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/narwhals/_compliant/expr.pybetweenzNativeExpr.betweenGcyrArBrCvalues rF__gt__zNativeExpr.__gt__MrHrIcyrArBrKs rF__lt__zNativeExpr.__lt__NrHrIcyrArBrKs rF__ge__zNativeExpr.__ge__OrHrIcyrArBrKs rF__le__zNativeExpr.__le__PrHrIcyrArBrKs rF__eq__zNativeExpr.__eq__QrHrIcyrArBrKs rF__ne__zNativeExpr.__ne__RrHrIN)rDrrErreturnr)rLrrXr') __name__ __module__ __qualname____doc__rGrMrOrQrSrUrWrBrIrFr>r>@s  ; 100000rIr>ceZdZUded<ded<ded<dZded <ed(d Z d)d Zd*d Zd+d Z e d,dZ e d-dZ d*dZ d.dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd*dZd/dZd/dZd*d Zd*d!Zd*d"Zd0d#Z d1d$Z! d2d%Z" d3d&Z#ed4d'Z$y)5r:r/_implementationEvalNames[CompliantFrameT]_evaluate_output_namesAliasNames | None_alias_output_namesNzExprMetadata | None _opt_metadatacL|j d}t||jS)Na3`_opt_metadata` is None. This is usually the result of trying to do some operation (such as `over`) which requires access to the metadata at the compliant level. You may want to consider rewriting your logic so that this operation is not necessary. Ideally you should avoid setting `_opt_metadata` manually.)rcAssertionError)rCmsgs rF _metadatazCompliantExpr._metadata`s1    %4 !% %!!!rIcyrArBrCdfs rF__call__zCompliantExpr.__call__ms47rIc|SrArBrCs rF__narwhals_expr__zCompliantExpr.__narwhals_expr__ps rIcyrArBrms rF__narwhals_namespace__z$CompliantExpr.__narwhals_namespace__srHrIcyrArB)clscontextcolumn_indicess rFfrom_column_indicesz!CompliantExpr.from_column_indicestsrIcyrArBrrevaluate_column_namesrss rFfrom_column_nameszCompliantExpr.from_column_namesxrIcyrArBrms rF broadcastzCompliantExpr.broadcastrHrIcyrArBrCnames rFaliaszCompliantExpr.aliasrHrIcyrArBrms rFallzCompliantExpr.allrHrIcyrArBrms rFanyzCompliantExpr.anyrHrIcyrArBrms rFcountzCompliantExpr.countrHrIcyrArBrms rFminzCompliantExpr.minrHrIcyrArBrms rFmaxzCompliantExpr.maxrHrIcyrArBrms rFmeanzCompliantExpr.meanrHrIcyrArBrms rFsumzCompliantExpr.sumrHrIcyrArBrms rFmedianzCompliantExpr.medianrHrIcyrArBrms rFfirstzCompliantExpr.firstrHrIcyrArBrms rFlastzCompliantExpr.lastrHrIcyrArBrms rFskewzCompliantExpr.skewrHrIcyrArBrms rFkurtosiszCompliantExpr.kurtosisrHrIcyrArBrCddofs rFstdzCompliantExpr.stdrHrIcyrArBrs rFvarzCompliantExpr.varrHrIcyrArBrms rFn_uniquezCompliantExpr.n_uniquerHrIcyrArBrms rF null_countzCompliantExpr.null_countrHrIcyrArBrms rFlenzCompliantExpr.lenrHrIcyrArB)rC partition_byorder_bys rFoverzCompliantExpr.overrHrIcyrArBrCquantile interpolations rFrzCompliantExpr.quantilesrIcyrArB)rCfunction return_dtypereturns_scalars rF map_batcheszCompliantExpr.map_batchess rIcyrArBrCdefaultoldnewrs rFreplace_strictzCompliantExpr.replace_strictrzrIcyrArBrms rFrzCompliantExpr.names+.rI)rXr-)rjrrXz)Sequence[CompliantSeriesOrNativeExprT_co]rXr')rXz)CompliantNamespace[CompliantFrameT, Self])rtintrsr1rXr')rxr_rsr1rXr'rstrrXr'rrrXr')r Sequence[str]rrrXr'rfloatrr8rXr')rz9Callable[[CompliantSeries[Any]], CompliantExpr[Any, Any]]rIntoDType | NonerboolrXr' rzSelf | NoDefaultr Sequence[Any]rrrrrXr')rXzNameNamespace[Self])%rYrZr[__annotations__rcpropertyrgrkrnrp classmethodruryr|rrrrrrrrrrrrrrrrrrrrrrrrBrIrFr:r:Us|$#66***.M&-  " "8!8 28W!,; 9 !   %, ! #,,#%U.H K'    !  '  ..rIr:c&eZdZeddZddZy)ImplExprcdfd }|S)NcL|j}Dcgc]}|| c}Scc}wrA)columns)rj column_namesiindicess rFfnz(ImplExpr._eval_names_indices..fns$::L-45LO5 55s !)rjrrXrrB)rrs` rF_eval_names_indiceszImplExpr._eval_names_indicess 6 rIcT|j|}|jx}r||S|SrA)r`rb)rCframenamesrs rF_evaluate_aliaseszImplExpr._evaluate_aliasess3++E2)-)A)A A AuU|MMrIN)rz Sequence[int]rXr_)rrrXr)rYrZr[ staticmethodrrrBrIrFrrsNrIrc6eZdZe ddZddZy)r;cyrArBrws rFryz#DepthTrackingExpr.from_column_namesrzrIc`tt|jjdkS)atCheck if expr is elementary. Examples: - nw.col('a').mean() # depth 1 - nw.mean('a') # depth 1 - nw.len() # depth 0 as opposed to, say - nw.col('a').filter(nw.col('b')>nw.col('c')).max() Elementary expressions are the only ones supported properly in pandas, PyArrow, and Dask. )rlistrgop_nodes_reversedrms rF_is_elementaryz DepthTrackingExpr._is_elementarys&488:;<AArIN)rrz type[Self]rxr_rsr1rXr')rXr)rYrZr[rryrrBrIrFr;r;s@ 9 !   BrIr;ceZdZUded< dqdZdrdZ dsdZe dtdZedudZ dvdZ d d  dwd Z d d  dxd Z edyd Z dzdZ d{dZd|dZd}dZd~dZd~dZddZddZddZddZddZddZddZddZddZddZddZddZdd Z dd!Z!dd"Z"dd#Z#dd$Z$dd%Z%dd&Z&dd'Z'd|d(Z(d|d)Z)d|d*Z*d|d+Z+d|d,Z,d|d-Z-d|d.Z.dd/Z/dd0Z0d|d1Z1d|d2Z2d|d3Z3d|d4Z4d|d5Z5d|d6Z6d|d7Z7d|d8Z8dd9Z9dd:Z:dd;Z;d|d<ZZ> dd?Z?dd@Z@d|dAZAddBZBd|dCZC ddDZDddEZEd|dFZFd|dGZGd|dHZH ddIZIddJZJd|dKZKd|dLZLd|dMZM ddNZNddOZOddPZPddQZQd|dRZRd|dSZSd|dTZTddUZUddVZVd|dWZWddXZX ddYZYddZZZ dd[Z[ dd\Z\dd]Z]dd^Z^dd_Z_dd`Z`ddaZaddbZbddcZcdddZdd|deZed|dfZf ddgZgd|dhZhd|diZiejddjZkejddkZlejddlZmejddmZnejddnZoejddoZpyp)r<)EvalSeries[EagerDataFrameT, EagerSeriesT]_callcyrArB)rCcallevaluate_output_namesalias_output_namesimplementationversions rF__init__zEagerExpr.__init__srIc$|j|SrA)rris rFrkzEagerExpr.__call__szz"~rIcyrArBrms rFrpz EagerExpr.__narwhals_namespace__sHKrIcD|||||j|jS)Nrrrrr^_version)rrfuncrrrss rF_from_callablezEagerExpr._from_callables, "71"22$$   rIcR|fdfddjjS)Nc gSrArB_dfseriess rFz(EagerExpr._from_series..s rIcjgSrArrs rFrz(EagerExpr._from_series..s v{{mrIrr)rrrs `rF _from_serieszEagerExpr._from_series s) ";#!11OO   rIcjdn fdnfddfd }j|jjjS)NcF|Dcgc] }| c}Scc}wrArB) output_namesx alias_namecurrent_alias_output_namess rFrz4EagerExpr._with_alias_output_names..s&+El+S&&'JqM&&sc:|Dcgc] }| c}Scc}wrArB)rrrs rFrz4EagerExpr._with_alias_output_names..!s|'L! 1 'L'Lc8rIt|j|Dcgc]\}}|j|c}}St|j|Dcgc]\}}|j|c}}Scc}}wcc}}wrA)r"r`r)rjrrrrCs rFrz0EagerExpr._with_alias_output_names..func$s!)3R"4T5P5PQS5T"U)$LL&%/tBx9T9TUW9X$Y FD T"   s B1BrrjrrXzlist[EagerSeriesT])rb __class__r`r^r)rCrrrrs`` @@rF_with_alias_output_namesz"EagerExpr._with_alias_output_namessp%)%=%="! *5  M  ~~ "&"="=1//MM   rIFrc t|jf||d|}|j||j|j|S)aReuse Series implementation for expression. If Series.foo is already defined, and we'd like Expr.foo to be the same, we can leverage this method to do that for us. Arguments: method_name: name of method. returns_scalar: whether the Series version returns a scalar. In this case, the expression version should return a 1-row Series. kwargs: keyword arguments to pass to function. ) method_namerrrrs)r_reuse_series_innerrr`rb)rCrrkwargsrs rF _reuse_serieszEagerExpr._reuse_series9s^  $ $ #)    "" "&"="=#77 #  rIciSrArB)rCrs rF_reuse_series_extra_kwargsz$EagerExpr._reuse_series_extra_kwargsVs  rIct|dS)Nrn)hasattr)rrobjs rF_is_exprzEagerExpr._is_expr[ss/00rIc |jDcic]*\}}||j|r|j|n|,}}}t|fi|j ||}||Dcgc]#}|r|j ||n||%} }|j |d| D} } tdt| | Drd| d} t| | Scc}}wcc}w)Nrc34K|]}|jywrAr).0ss rF z0EagerExpr._reuse_series_inner..vs5Jaff5Jc3,K|] \}}||k7ywrArB)rrrs rFrz0EagerExpr._reuse_series_inner..ws )eTETM sztSafety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues Expression aliases:  ) itemsr_evaluate_single_output_exprrr  _from_scalarrrr"re) rCrjrrr rrLmethodroutaliasesrrfs rFr zEagerExpr._reuse_series_inner_s( &||~  e }}U#11%8     --^-L  r(' 4BF  v /vf~ U' ' //35Jc5J  -7-G  ''.ir3 !% % 1 ' s /C!.(C'c ndfd }j|jjS)aReuse Series implementation for expression. Just like `_reuse_series`, but for e.g. `Expr.dt.foo` instead of `Expr.foo`. Arguments: series_namespace: The Series namespace. method_name: name of method, within `series_namespace`. expressifiable_args: keyword arguments to pass to function, which may be expressifiable (e.g. `nw.col('a').str.replace('abc', nw.col('b')))`). c jDcic]*\}}|j|r|j|n|,}}}|Dcgc]}tt|di| c}Scc}}wcc}w)NrB)rrrgetattr) rjrrLr rexpressifiable_argsrrCseries_namespaces rFinnerz0EagerExpr._reuse_series_namespace..inners $7#<#<#>  D%=='55e<F#2hH(89;GQ&Q   s /A7#A=rrrr`rb)rCr$rr#r%s```` rF_reuse_series_namespacez!EagerExpr._reuse_series_namespaces?$  "" "&"="=#77 #  rIcdfd }t|jjjjS)NcVg}|D]}d|_|j||S)NT) _broadcastappend)rjresultsresultrCs rFrz!EagerExpr.broadcast..funcs6Gr( '$(!v& 'NrIrr)typer`rbr^rrCrs` rFr|zEagerExpr.broadcastsB tDz "&"="=#77//MM   rIc(|jd|S)Ncast)dtyper )rCr2s rFr1zEagerExpr.casts!!&!66rIc(|j||S)Notherr3rCoperatorr6s rF _with_binaryzEagerExpr._with_binarys!!(%!88rIcF|jdj||S)Nliteralr5)rr r7s rF_with_binary_rightzEagerExpr._with_binary_rights!zz)$22852IIrIc&|jd|S)NrUr9rCr6s rFrUzEagerExpr.__eq__  511rIc&|jd|S)NrWr>r?s rFrWzEagerExpr.__ne__r@rIc&|jd|S)NrQr>r?s rFrQzEagerExpr.__ge__r@rIc&|jd|S)NrMr>r?s rFrMzEagerExpr.__gt__r@rIc&|jd|S)NrSr>r?s rFrSzEagerExpr.__le__r@rIc&|jd|S)NrOr>r?s rFrOzEagerExpr.__lt__r@rIc&|jd|S)N__and__r>r?s rFrGzEagerExpr.__and__  E22rIc&|jd|S)N__or__r>r?s rFrJzEagerExpr.__or__r@rIc&|jd|S)N__add__r>r?s rFrLzEagerExpr.__add__rHrIc&|jd|S)N__sub__r>r?s rFrNzEagerExpr.__sub__rHrIc&|jd|S)N__rsub__r<r?s rFrPzEagerExpr.__rsub__&&z599rIc&|jd|S)N__mul__r>r?s rFrTzEagerExpr.__mul__rHrIc&|jd|S)N __truediv__r>r?s rFrVzEagerExpr.__truediv__s  66rIc&|jd|S)N __rtruediv__rQr?s rFrXzEagerExpr.__rtruediv__s&&~u==rIc&|jd|S)N __floordiv__r>r?s rFrZzEagerExpr.__floordiv__s  77rIc&|jd|S)N __rfloordiv__rQr?s rFr\zEagerExpr.__rfloordiv__s&&>>rIc&|jd|S)N__pow__r>r?s rFr^zEagerExpr.__pow__rHrIc&|jd|S)N__rpow__rQr?s rFr`zEagerExpr.__rpow__rRrIc&|jd|S)N__mod__r>r?s rFrbzEagerExpr.__mod__rHrIc&|jd|S)N__rmod__rQr?s rFrdzEagerExpr.__rmod__rRrIc$|jdS)N __invert__r3rms rFrfzEagerExpr.__invert__!!,//rIc(|jddS)NrTrr3rms rFrzEagerExpr.null_counts!!,t!DDrIc(|jddS)NrTrr3rms rFrzEagerExpr.n_unique!!*T!BBrIc(|jddS)NrTrr3rms rFrz EagerExpr.sum !!%!==rIc(|jddS)NrTrr3rms rFrzEagerExpr.count !!'$!??rIc(|jddS)NrTrr3rms rFrzEagerExpr.mean!!&!>>rIc(|jddS)NrTrr3rms rFrzEagerExpr.medians!!(4!@@rIc*|jdd|S)NrTrrr3rs rFrz EagerExpr.std!!%4!HHrIc*|jdd|S)NrTrsr3rs rFrz EagerExpr.varrtrIc(|jddS)NrTrr3rms rFrzEagerExpr.skewrprIc(|jddS)NrTrr3rms rFrzEagerExpr.kurtosisrjrIc(|jddS)NrTrr3rms rFrz EagerExpr.any!rlrIc(|jddS)NrTrr3rms rFrz EagerExpr.all$rlrIc(|jddS)NrTrr3rms rFrz EagerExpr.max'rlrIc(|jddS)NrTrr3rms rFrz EagerExpr.min*rlrIc(|jddS)Narg_minTrr3rms rFr}zEagerExpr.arg_min-!!)D!AArIc(|jddS)Narg_maxTrr3rms rFrzEagerExpr.arg_max0r~rIc*|jd||S)Nclip) lower_bound upper_boundr3)rCrrs rFrzEagerExpr.clip5s!!!  "  rIc(|jd|S)N clip_lower)rr3)rCrs rFrzEagerExpr.clip_lower:!!,K!HHrIc(|jd|S)N clip_upper)rr3)rCrs rFrzEagerExpr.clip_upper=rrIc$|jdS)Nis_nullr3rms rFrzEagerExpr.is_null@s!!),,rIc$|jdS)Nis_nanr3rms rFrzEagerExpr.is_nanCs!!(++rIc(|jd|S)Nfill_nan)rLr3rKs rFrzEagerExpr.fill_nanFs!!*E!::rIc,|jd|||S)N fill_null)rLstrategylimitr3)rCrLrrs rFrzEagerExpr.fill_nullIs%!! uxu"  rIc(|jd|S)Nis_inr5r3r?s rFrzEagerExpr.is_inPs!!'!77rIc$|jdS)Narg_truer3rms rFrzEagerExpr.arg_trueSs!!*--rIcl|j}|j|ddi}|jd|S)N ignore_nullsFfilter) predicate)rpall_horizontalr )rC predicatesplxrs rFrzEagerExpr.filterVs=))+&C&& GG !!(i!@@rIc$|jdS)N drop_nullsr3rms rFrzEagerExpr.drop_nulls[rgrIc.|jd||||S)Nr)rrrrr3rs rFrzEagerExpr.replace_strict^s'!! #3l"  rIc*|jd||S)Nsort) descending nulls_lastr3)rCrrs rFrzEagerExpr.sortjs!!&ZJ!WWrIc$|jdS)Nabsr3rms rFrz EagerExpr.absm!!%((rIc(|jddS)NuniqueF)maintain_orderr3rms rFrzEagerExpr.uniqueps!!(5!AArIc$|jdS)Ndiffr3rms rFrzEagerExpr.diffs!!&))rIc.|jd||||S)Nsample)nfractionwith_replacementseedr3)rCrrrrs rFrzEagerExpr.samplevs)!! H?OVZ"  rIcdfd }tfdj|jjS)NcFt|dk7rd|}t|gSNz:Expected function with single output, found output names: )rr%rrfrs rFrz+EagerExpr.alias..alias_output_namess.5zQRSXRYZ0556MrIcX|Dcgc]}|jc}Scc}wrAr)rjrrrCs rFrz!EagerExpr.alias..s"bBv T*BBs'rrrrXr)r.r`r^r)rCrrs`` rFrzEagerExpr.aliass<  tDz B"&"="=1//MM   rIc$|jdS)N is_uniquer3rms rFrzEagerExpr.is_unique!!+..rIc$|jdS)Nis_first_distinctr3rms rFrzEagerExpr.is_first_distincts!!"566rIc$|jdS)Nis_last_distinctr3rms rFrzEagerExpr.is_last_distincts!!"455rIc,|jdd||S)NrT)rrrr3rs rFrzEagerExpr.quantiles(!! ' "  rIc(|jd|S)Nheadrr3rCrs rFrzEagerExpr.head!!&A!..rIc(|jd|S)Ntailrr3rs rFrzEagerExpr.tailrrIc(|jd|S)Nround)decimalsr3)rCrs rFrzEagerExpr.rounds!!'H!==rIc$|jdS)Nfloorr3rms rFrzEagerExpr.floors!!'**rIc$|jdS)Nceilr3rms rFrzEagerExpr.ceilrrIc(|jddS)NrTrr3rms rFrz EagerExpr.lenrlrIc*|jd||S)N gather_every)roffsetr3)rCrrs rFrzEagerExpr.gather_everys!!.Af!EErIc(|jd|S)Nmode)keepr3)rCrs rFrzEagerExpr.modes!!&t!44rIc$|jdS)N is_finiter3rms rFrzEagerExpr.is_finiterrIc,|jd|||S)N rolling_mean window_size min_samplescenterr3rCrrrs rFrzEagerExpr.rolling_means&!! ## "  rIc.|jd||||S)N rolling_stdrrrrr3rCrrrrs rFrzEagerExpr.rolling_std+!! ## "  rIc,|jd|||S)N rolling_sumrr3rs rFrzEagerExpr.rolling_sums$!! { TZ"  rIc.|jd||||S)N rolling_varrr3rs rFrzEagerExpr.rolling_varrrIcndfd }j|jjS)Nc |}d|D}tfd|D}|d|d}}t||}t|s t|r,t |j  t fd|D}nIt ||jrtd|D}n |j t fd|D}tfd|D}td |D}sRt|rGt|d kDr9|jd } t|| } d t| d } t| |S)Nc34K|]}|jywrAr)r input_seriess rFrz6EagerExpr.map_batches..func..sP,L--Prc3.K|] }|ywrArB)rrrs rFrz6EagerExpr.map_batches..func..s"P8F#3"Psr)rsc3RK|]\}}|j| ywrAr)rarrout_name from_numpys rFrz6EagerExpr.map_batches..func..s$W=3z#44X>W$'c3DK|]\}}|j|ywrAr)rrrs rFrz6EagerExpr.map_batches..func..sQ:J&(v||H5Qs c3RK|]\}}|j| ywrAr)rvalr from_scalars rFrz6EagerExpr.map_batches..func..s%XMC{3/55h?Xrc3@K|]}|jywrA)r1)rrrs rFrz6EagerExpr.map_batches..func..sNVv{{<8Nsc38K|]}t|dk(yw)rN)r)rrs rFrz6EagerExpr.map_batches..func..s$AQSVq[$AsrTzG`map_batches` with `returns_scalar=False` must return a Series; found 'zQ'. If `returns_scalar` is set to `True`, a returned value can be a scalar value.)tupler"r#r$rr isinstancerrrrindexr.r! TypeError)rj udf_series_inrudf_series_out _first_in _first_outitr-is_scalar_result_idx_typerfrrrrrrCs @@rFrz#EagerExpr.map_batches..funcsB HMP-PL""P-"PPN$1!$4nQ6GzINL9Bj)_Z-H$Y%9%94H WTVWWJ (;(;<QbQQ'44 XUWXX'NvNN$$A&$AA ",<(=3r7Q;'--d3^D121%89:PP  n$MrIrrjrrXSequence[EagerSeriesT]r&)rCrrrrs```` rFrzEagerExpr.map_batchess@  @"" "&"="=#77 #  rIc(|jd|S)Nshiftrr3rs rFr zEagerExpr.shifts!!'Q!//rIc(|jd|S)Ncum_sumreverser3rCrs rFrzEagerExpr.cum_sum!!)W!==rIc(|jd|S)N cum_countrr3rs rFrzEagerExpr.cum_counts!!+w!??rIc(|jd|S)Ncum_minrr3rs rFrzEagerExpr.cum_minrrIc(|jd|S)Ncum_maxrr3rs rFrzEagerExpr.cum_maxrrIc(|jd|S)Ncum_prodrr3rs rFrzEagerExpr.cum_prods!!*g!>>rIc*|jd||S)Nrank)rrr3)rCrrs rFrzEagerExpr.rank"s!!&J!OOrIc(|jd|S)Nlog)baser3)rCrs rFrz EagerExpr.log%s!!%d!33rIc$|jdS)Nexpr3rms rFr!z EagerExpr.exp(rrIc$|jdS)Nsqrtr3rms rFr#zEagerExpr.sqrt+rrIc,|jd|||S)N is_between)rrclosedr3)rCrrr&s rFr%zEagerExpr.is_between.s&!! k{SY"  rIc(|jddS)NrTrr3rms rFrzEagerExpr.first5rnrIc(|jddS)NrTrr3rms rFrzEagerExpr.last8rprIct|SrA)EagerExprCatNamespacerms rFcatz EagerExpr.cat; $T**rIct|SrA)EagerExprDateTimeNamespacerms rFdtz EagerExpr.dt?s )$//rIct|SrA)EagerExprListNamespacerms rFrzEagerExpr.listC %d++rIct|SrA)EagerExprNameNamespacerms rFrzEagerExpr.nameGr2rIct|SrA)EagerExprStringNamespacerms rFrz EagerExpr.strK '--rIct|SrA)EagerExprStructNamespacerms rFstructzEagerExpr.structOr7rIN) rrrEvalNames[EagerDataFrameT]rrarr/rr0rXNoner )rXz=EagerNamespace[EagerDataFrameT, EagerSeriesT, Self, Any, Any]) rrrr;rrarsr1rXr')rrrXr')rAliasName | NonerXr')rrrrr rrXr')rrrXzdict[str, Any])rz Self | AnyrXz TypeIs[Self]) rjrrrrrr rrXr )r$z5Literal['cat', 'dt', 'list', 'name', 'str', 'struct']rrr#rrXr'r)r2r4rXr')r8rr6r'rXr')r6r'rXr'r)rr'rr'rXr')rr'rXr')rr'rXr')rL float | NonerXr')rLz Self | NonerzFillNullStrategy | Noner int | NonerXr')r6rrXr')rr'rXr'r)rrrrrXr') rr?rr>rrrr?rXr'rr)rrrXr')rrrXr')rrrrrXr')rr5rXr')rrrrrrrXr') rrrrrrrrrXr')rzCallable[[Any], Any]rrrrrXr')rrrXr')rr7rrrXr')rrrXr')rr'rr'r&r2rXr')rXzEagerExprCatNamespace[Self])rXz EagerExprDateTimeNamespace[Self])rXzEagerExprListNamespace[Self])rXzEagerExprNameNamespace[Self])rXzEagerExprStringNamespace[Self])rXzEagerExprStructNamespace[Self])qrYrZr[rrrkrprrrrr r rr r'r|r1r9r<rUrWrQrMrSrOrGrJrLrNrPrTrVrXrZr\r^r`rbrdrfrrrrrrrrrrrrrrr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrr!r#r%rrrr+r/rrrr:rBrIrFr<r<s 547 :  .  '  L FL 7  :  .  !       ! H;@  37 KN  <).!%  11          D# O# #  # #  # J &79J2222223233:37>8?3:3:0EC>@?AII?C>>>>BB  II-,;   ,C LV  8.A 0  !      '     X)B*               /76  .H  //>+*>F5/     03  =A  IL        03  =A  IL    , &, ',  ,  , \0>@>>?P4)*  .2 .fnZs-5zQRSXRYZ o%6MrIr)r)rCrrs ` rFrzLazyExpr.aliasYs  ,,R00rIct|SrA)LazyExprNameNamespacerms rFrz LazyExpr.namebr,rIr r+N)rrarXr'r)rXzLazyExprNameNamespace[Self]) rYrZr[rrrrr ewm_meanrr+rrBrIrFr=r=Us@P1++ H!#K*,C,rIr=c*eZdZUded<eddZy)_ExprNamespacer_compliant_exprc|jSrArJrms rF compliantz_ExprNamespace.compliantps###rINrXr)rYrZr[rrrMrBrIrFrIrIks'& $$rIrIceZdZddZy)EagerExprNamespacec||_yrArLrCexprs rFrzEagerExprNamespace.__init__v #rIN)rSrrXr<rYrZr[rrBrIrFrPrPu$rIrPceZdZddZy)LazyExprNamespacec||_yrArLrRs rFrzLazyExprNamespace.__init__{rTrIN)rSrrXr<rUrBrIrFrXrXzrVrIrXceZdZddZy)r*c:|jjddS)Nr+get_categoriesrMr'rms rFr\z$EagerExprCatNamespace.get_categoriess~~55e=MNNrINrXr)rYrZr[r\rBrIrFr*r*sOrIr*ceZdZddZddZddZddZddZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZddZddZddZddZddZddZddZddZddZddZy) r.c>|jjdd|S)Nr/ to_stringformatr]rCrcs rFraz$EagerExprDateTimeNamespace.to_strings~~55dKPV5WWrIc>|jjdd|S)Nr/replace_time_zone time_zoner]rCrhs rFrfz,EagerExprDateTimeNamespace.replace_time_zone&~~55 %6  rIc>|jjdd|S)Nr/convert_time_zonergr]ris rFrlz,EagerExprDateTimeNamespace.convert_time_zonerjrIc>|jjdd|S)Nr/ timestamp) time_unitr])rCros rFrnz$EagerExprDateTimeNamespace.timestamps%~~55 +6  rIc:|jjddS)Nr/dater]rms rFrqzEagerExprDateTimeNamespace.date~~55dFCCrIc:|jjddS)Nr/yearr]rms rFrtzEagerExprDateTimeNamespace.yearrrrIc:|jjddS)Nr/monthr]rms rFrvz EagerExprDateTimeNamespace.months~~55dGDDrIc:|jjddS)Nr/dayr]rms rFrxzEagerExprDateTimeNamespace.days~~55dEBBrIc:|jjddS)Nr/hourr]rms rFrzzEagerExprDateTimeNamespace.hourrrrIc:|jjddS)Nr/minuter]rms rFr|z!EagerExprDateTimeNamespace.minute~~55dHEErIc:|jjddS)Nr/secondr]rms rFrz!EagerExprDateTimeNamespace.secondr}rIc:|jjddS)Nr/ millisecondr]rms rFrz&EagerExprDateTimeNamespace.millisecond~~55dMJJrIc:|jjddS)Nr/ microsecondr]rms rFrz&EagerExprDateTimeNamespace.microsecondrrIc:|jjddS)Nr/ nanosecondr]rms rFrz%EagerExprDateTimeNamespace.nanoseconds~~55dLIIrIc:|jjddS)Nr/ ordinal_dayr]rms rFrz&EagerExprDateTimeNamespace.ordinal_dayrrIc:|jjddS)Nr/weekdayr]rms rFrz"EagerExprDateTimeNamespace.weekdays~~55dIFFrIc:|jjddS)Nr/ total_minutesr]rms rFrz(EagerExprDateTimeNamespace.total_minutes~~55dOLLrIc:|jjddS)Nr/ total_secondsr]rms rFrz(EagerExprDateTimeNamespace.total_secondsrrIc:|jjddS)Nr/total_millisecondsr]rms rFrz-EagerExprDateTimeNamespace.total_milliseconds~~55d|jjdd|S)Nr/truncate)everyr])rCrs rFrz#EagerExprDateTimeNamespace.truncates~~55dJe5TTrIc>|jjdd|S)Nr/ offset_bybyr]rCrs rFrz$EagerExprDateTimeNamespace.offset_bys~~55dKB5OOrIN)rcrrXr)rh str | NonerXr)rhrrXr)ror9rXrr^)rrrXrrrrXr)rYrZr[rarfrlrnrqrtrvrxrzr|rrrrrrrrrrrrrrBrIrFr.r.sX   DDECDFFKKJKGMMRRQUPrIr.c,eZdZddZddZddZddZy) r1c:|jjddS)Nrrr]rms rFrzEagerExprListNamespace.lens~~55feDDrIc:|jjddS)Nrrr]rms rFrzEagerExprListNamespace.uniques~~55fhGGrIc>|jjdd|S)Nrcontains)itemr])rCrs rFrzEagerExprListNamespace.containss~~55fjt5TTrIc>|jjdd|S)Nrget)rr])rCrs rFrzEagerExprListNamespace.gets~~55fe55QQrINr^)rr6rXr)rrrXr)rYrZr[rrrrrBrIrFr1r1sEHURrIr1cVeZdZd dZd dZd dZd dZd dZd dZe ddZ ddZ y )CompliantExprNameNamespacec$|jdSrArrms rFrzCompliantExprNameNamespace.keeps""4((rIc$|j|SrAr)rCrs rFmapzCompliantExprNameNamespace.maps""8,,rIc,|jfdS)Nc|SrArB)rprefixs rFrz3CompliantExprNameNamespace.prefix..s6(4&0ArIrrCrs `rFrz!CompliantExprNameNamespace.prefix""#ABBrIc,|jfdS)Nc|SrArB)rsuffixs rFrz3CompliantExprNameNamespace.suffix..s4&0ArIrrCrs `rFrz!CompliantExprNameNamespace.suffixrrIc@|jtjSrA)rrlowerrms rF to_lowercasez'CompliantExprNameNamespace.to_lowercase""399--rIc@|jtjSrA)rrupperrms rF to_uppercasez'CompliantExprNameNamespace.to_uppercaserrIcdfd }|S)Nc:|Dcgc] }| c}Scc}wrArB)rrrs rFrz:CompliantExprNameNamespace._alias_output_names..fns+784DJ8 88r)rrrXrrB)rrs` rFrbz.CompliantExprNameNamespace._alias_output_namess 9 rIcyrArBr/s rFrz)CompliantExprNameNamespace._from_callablerHrINrN)rrrXr)rrrXr)rrrXr)rrrXr)rr=rXr) rYrZr[rrrrrrrrbrrBrIrFrrs< )-CC.. RrIrceZdZddZy)r4c<|j}|j|SrA)rMr)rCrrSs rFrz%EagerExprNameNamespace._from_callable s~~,,T22rIN)rr=rXrrYrZr[rrBrIrFr4r4s 3rIr4ceZdZddZy)rFcf|j}|r|j|nd}|j|SrA)rMrbr)rCrrSrs rFrz$LazyExprNameNamespace._from_callables0~~9=t//54 ,,\::rIN)rr=rXrrrBrIrFrFrFs ;rIrFceZdZddZ ddZ ddZddZddZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZddZddZy)r6c:|jjddS)Nr len_charsr]rms rFrz"EagerExprStringNamespace.len_charss~~55e[IIrIcD|jjdd||||S)Nrreplace)patternrLr;rr])rCrLrr;rs rFrz EagerExprStringNamespace.replace!s-~~55 9gUGq6  rIcB|jjdd|||S)Nr replace_all)rrLr;r])rCrLrr;s rFrz$EagerExprStringNamespace.replace_all(s+~~55 ='6  rIc>|jjdd|S)Nr strip_chars) charactersr])rCrs rFrz$EagerExprStringNamespace.strip_chars/s%~~55 =Z6  rIc>|jjdd|S)Nr starts_with)rr]rs rFrz$EagerExprStringNamespace.starts_with4~~55e]SY5ZZrIc>|jjdd|S)Nr ends_with)rr]rs rFrz"EagerExprStringNamespace.ends_with7s~~55e[QW5XXrIc@|jjdd||S)Nrr)rr;r])rCrr;s rFrz!EagerExprStringNamespace.contains:s'~~55 :w6  rIc@|jjdd||S)Nrslice)rlengthr])rCrrs rFrzEagerExprStringNamespace.slice?s'~~55 76&6  rIc>|jjdd|S)Nrsplitrr]rs rFrzEagerExprStringNamespace.splitDs~~55eW5LLrIc>|jjdd|S)Nr to_datetimerbr]rds rFrz$EagerExprStringNamespace.to_datetimeGrrIc>|jjdd|S)Nrto_daterbr]rds rFrz EagerExprStringNamespace.to_dateJs~~55eYv5VVrIc:|jjddS)Nrrr]rms rFrz%EagerExprStringNamespace.to_lowercaseM~~55e^LLrIc:|jjddS)Nrrr]rms rFrz%EagerExprStringNamespace.to_uppercasePrrIc>|jjdd|S)Nrzfill)widthr])rCrs rFrzEagerExprStringNamespace.zfillSs~~55eWE5RRrIc:|jjddS)Nr to_titlecaser]rms rFrz%EagerExprStringNamespace.to_titlecaseVrrINr^) rLrrrr;rrrrXr)rLrrrr;rrXr)rrrXr)rrrXr)rrrXr)rrr;rrXr)rrrr?rXrr)rcrrXr)rrrXr)rYrZr[rrrrrrrrrrrrrrrrBrIrFr6r6sJ  *- ;? DG    *- ;?   [Y  M[WMMSMrIr6ceZdZddZy)r9c\|jjdd|j|S)Nr:fieldr)rMr'rr~s rFrzEagerExprStructNamespace.field]s.~~55hd5SYY   rIN)rrrXr)rYrZr[rrBrIrFr9r9Zs rIr9N)Z __future__r functoolsrr8rtypingrrrr r r !narwhals._compliant.any_namespacer r rrrrnarwhals._compliant.columnrnarwhals._compliant.namespacernarwhals._compliant.typingrrrrrrrrrrrnarwhals._utilsrr r!r"narwhals.dependenciesr#r$narwhals.exceptionsr%collections.abcr&typing_extensionsr'r(r)narwhals._compliant.seriesr*r+r,narwhals._expression_parsingr-narwhals._typingr.r/r0r1narwhals.typingr2r3r4r5r6r7r8r9__all__r>r:rr;r<r=rIrPrXr*r.r1rr4rFr6r9rBrIrFrs"!KK7<     B:(.P:LL9*HH    X11*T/Xo/NNOT/nN/#BBC _= =>N("B _= => _= =>"BJl .o|34 _l *+l .`- + -.9Lk9Y0Z-,$&'2C)D$$ 3WZ5H$ $y1793E$ Oz"L$QOLPz"$5j$A7:CVLP^ Rz"M*$=wz?R R R$%#$ RB3z"z* J3;i y) I;<Mz"OJ$?AT<M~ z"OJ$?AT rI