
    ^j6                    8   d dl mZ d dlmZ d dlmZ d dlmZmZm	Z	m
Z
mZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZm Z  d dl!m"Z"m#Z#m$Z$m%Z% d d	l&m'Z'm(Z( d d
l)m*Z* erPd dl+m,Z,m-Z- d dl.m/Z/m0Z0 d dl1m2Z2m3Z3 d dl4m5Z5 d dlm6Z6m7Z7 d dl8m9Z9 d dl:m;Z; d dl!m<Z<m=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZG g dZH G d de      ZI G d deeeef         ZJ G d deJeef   eeef         ZK G d deKeef   eeef         ZL G d deLeef   eeef         ZM G d d eKee f   eee f         ZN G d! d"e#e   ee         ZO G d# d$eOe   e	e         ZP G d% d&eOe   e	e         ZQ G d' d(ePe   ee   e	e         ZR G d) d*ePe   ee   e	e         ZS G d+ d,ePe   ee   e	e         ZT G d- d.eOe   ee   ee         ZU G d/ d0ePe   eUe   e	e         ZV G d1 d2eQe   eUe   e	e         ZW G d3 d4ePe   ee   e	e         ZX G d5 d6ePe   ee   e	e         ZYy7)8    )annotations)partial)methodcaller)TYPE_CHECKINGAnyGenericLiteralProtocol)CatNamespaceDateTimeNamespaceListNamespaceNameNamespaceStringNamespaceStructNamespace)CompliantColumn)	AliasName
AliasNamesCompliantExprT_coCompliantFrameTCompliantLazyFrameTCompliantSeriesOrNativeExprT_coEagerDataFrameT
EagerExprTEagerSeriesT	LazyExprTNativeExprT)_resolve_sample_size_StoresCompliantnot_implementedqualified_type_name)is_numpy_arrayis_numpy_scalar)MultiOutputExpressionError)CallableSequence)SelfTypeIs)CompliantNamespaceEagerNamespace)CompliantSeries)	EvalNames
EvalSeries)ExprMetadata)	NoDefault)ImplementationVersion_LimitedContext)ClosedIntervalFillNullStrategy	IntoDTypeModeKeepStrategyNonNestedLiteral
RankMethodRollingInterpolationMethodTimeUnit)CompliantExprDepthTrackingExpr	EagerExprLazyExpr
NativeExprc                  H    e Zd ZdZd
dZddZddZddZddZddZ	ddZ
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.
    c                     y N )selfargskwdss      Q/opt/ringagent/.cad-venv/lib/python3.12/site-packages/narwhals/_compliant/expr.pybetweenzNativeExpr.betweenF           c                    y rA   rB   rC   values     rF   __gt__zNativeExpr.__gt__L   rH   rI   c                    y rA   rB   rK   s     rF   __lt__zNativeExpr.__lt__M   rH   rI   c                    y rA   rB   rK   s     rF   __ge__zNativeExpr.__ge__N   rH   rI   c                    y rA   rB   rK   s     rF   __le__zNativeExpr.__le__O   rH   rI   c                    y rA   rB   rK   s     rF   __eq__zNativeExpr.__eq__P   rH   rI   c                    y rA   rB   rK   s     rF   __ne__zNativeExpr.__ne__Q   rH   rI   N)rD   r   rE   r   returnr   )rL   r   rX   r&   )__name__
__module____qualname____doc__rG   rM   rO   rQ   rS   rU   rW   rB   rI   rF   r>   r>   ?   s      ; 100000rI   r>   c                     e Zd ZU ded<   ded<   ded<   dZded	<   ed*d
       Z	 	 	 	 d+dZd,dZd-dZ	e
	 	 	 	 	 	 d.d       Ze
	 	 	 	 	 	 d/d       Zd,dZd,dZd0dZd,dZd,dZd1dZd,dZd,dZd,dZd,dZd,dZd,dZd2d3dZd2d3dZd,dZd,dZd4d Zd4d!Zd,d"Zd,d#Z d,d$Z!d5d%Z"	 	 	 	 	 	 d6d&Z#	 	 	 	 	 	 	 	 d7d'Z$	 	 	 	 	 	 	 	 	 	 d8d(Z%ed9d)       Z&y):r:   r/   _implementationEvalNames[CompliantFrameT]_evaluate_output_namesAliasNames | None_alias_output_namesNzExprMetadata | None_opt_metadatac                L    | j                   d}t        |      | j                   S )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.)rc   AssertionError)rC   msgs     rF   	_metadatazCompliantExpr._metadata_   s1    %4  !%%!!!rI   c                     y rA   rB   rC   dfs     rF   __call__zCompliantExpr.__call__l   s    47rI   c                    | S rA   rB   rC   s    rF   __narwhals_expr__zCompliantExpr.__narwhals_expr__o   s    rI   c                     y rA   rB   rm   s    rF   __narwhals_namespace__z$CompliantExpr.__narwhals_namespace__r   rH   rI   c                    y rA   rB   )clscontextcolumn_indicess      rF   from_column_indicesz!CompliantExpr.from_column_indicess   s     rI   c                   y rA   rB   rr   evaluate_column_namesrs   s      rF   from_column_nameszCompliantExpr.from_column_namesw        rI   c                     y rA   rB   rm   s    rF   	broadcastzCompliantExpr.broadcast   rH   rI   c                h    | j                         }| |j                  dd       j                         z   S )Ng        )rp   litr|   )rC   plxs     rF   _is_close_float_promotez%CompliantExpr._is_close_float_promote   s1     ))+cggc4(22444rI   c                     y rA   rB   rC   names     rF   aliaszCompliantExpr.alias   rH   rI   c                     y rA   rB   rm   s    rF   allzCompliantExpr.all   rH   rI   c                     y rA   rB   rm   s    rF   anyzCompliantExpr.any   rH   rI   c                    y rA   rB   rC   ignore_nullss     rF   	any_valuezCompliantExpr.any_value   rH   rI   c                     y rA   rB   rm   s    rF   countzCompliantExpr.count   rH   rI   c                     y rA   rB   rm   s    rF   minzCompliantExpr.min   rH   rI   c                     y rA   rB   rm   s    rF   maxzCompliantExpr.max   rH   rI   c                     y rA   rB   rm   s    rF   meanzCompliantExpr.mean   rH   rI   c                     y rA   rB   rm   s    rF   sumzCompliantExpr.sum   rH   rI   c                     y rA   rB   rm   s    rF   medianzCompliantExpr.median   rH   rI   c                     y rA   rB   rC   order_bys     rF   firstzCompliantExpr.first   rH   rI   c                     y rA   rB   r   s     rF   lastzCompliantExpr.last   rH   rI   c                     y rA   rB   rm   s    rF   skewzCompliantExpr.skew   rH   rI   c                     y rA   rB   rm   s    rF   kurtosiszCompliantExpr.kurtosis   rH   rI   c                    y rA   rB   rC   ddofs     rF   stdzCompliantExpr.std   rH   rI   c                    y rA   rB   r   s     rF   varzCompliantExpr.var   rH   rI   c                     y rA   rB   rm   s    rF   n_uniquezCompliantExpr.n_unique   rH   rI   c                     y rA   rB   rm   s    rF   
null_countzCompliantExpr.null_count   rH   rI   c                     y rA   rB   rm   s    rF   lenzCompliantExpr.len   rH   rI   c                     y rA   rB   )rC   partition_byr   s      rF   overzCompliantExpr.over   rH   rI   c                     y rA   rB   rC   quantileinterpolations      rF   r   zCompliantExpr.quantile   s    rI   c                    y rA   rB   )rC   functionreturn_dtypereturns_scalars       rF   map_batcheszCompliantExpr.map_batches   s     rI   c                    y rA   rB   rC   defaultoldnewr   s        rF   replace_strictzCompliantExpr.replace_strict   rz   rI   c                     y rA   rB   rm   s    rF   r   zCompliantExpr.name   s    +.rI   )rX   r-   )rj   r   rX   z)Sequence[CompliantSeriesOrNativeExprT_co]rX   r&   )rX   z)CompliantNamespace[CompliantFrameT, Self])rt   intrs   r1   rX   r&   )rx   r_   rs   r1   rX   r&   r   strrX   r&   r   boolrX   r&   rB   r   Sequence[str]rX   r&   r   r   rX   r&   )r   r   r   r   rX   r&   r   floatr   r8   rX   r&   )r   z9Callable[[CompliantSeries[Any]], CompliantExpr[Any, Any]]r   IntoDType | Noner   r   rX   r&   
r   zSelf | NoDefaultr   Sequence[Any]r   r   r   r   rX   r&   )rX   zNameNamespace[Self])'rY   rZ   r[   __annotations__rc   propertyrg   rk   rn   rp   classmethodru   ry   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rB   rI   rF   r:   r:   T   s    $#66** *.M&-
" 
"8!8	28 W!,;	  9
 ! 
  %5 ,; !>=#,,#%U.H	K '
  
!  	 ' 
 . .rI   r:   c                  &    e Zd Zedd       ZddZy)ImplExprc                    d fd}|S )Nc                L    | j                   }D cg c]  }||   	 c}S c c}w rA   )columns)rj   column_namesiindicess      rF   fnz(ImplExpr._eval_names_indices.<locals>.fn   s$    ::L-45LO555s   !)rj   r   rX   r   rB   )r   r   s   ` rF   _eval_names_indiceszImplExpr._eval_names_indices   s    	6 	rI   c               T    | j                  |      }| j                  x}r ||      S |S rA   )r`   rb   )rC   framenamesr   s       rF   _evaluate_aliaseszImplExpr._evaluate_aliases   s3     ++E2)-)A)A A AuU|MMrI   N)r   zSequence[int]rX   r_   )r   r   rX   r   )rY   rZ   r[   staticmethodr   r   rB   rI   rF   r   r      s      NrI   r   c                  6    e Zd Ze	 	 	 	 	 	 	 	 dd       ZddZy)r;   c                   y rA   rB   rw   s      rF   ry   z#DepthTrackingExpr.from_column_names   rz   rI   c                `    t        t        | j                  j                                     dk  S )at  Check 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.
           )r   listrg   op_nodes_reversedrm   s    rF   _is_elementaryz DepthTrackingExpr._is_elementary   s&     488:;<AArI   N)rr   z
type[Self]rx   r_   rs   r1   rX   r&   )rX   r   )rY   rZ   r[   r   ry   r   rB   rI   rF   r;   r;      s@     9
 ! 
 BrI   r;   c                     e Zd ZU ded<   	 	 	 	 	 	 	 	 	 	 	 	 dudZdvdZ	 	 dwdZe	 	 	 	 	 	 	 	 	 	 dxd       Zedyd       Z	dzdZ
d	d
	 	 	 	 	 	 	 d{dZd	d
	 	 	 d|dZed}d       Z	 	 	 	 	 	 	 	 	 	 d~dZ	 	 	 	 	 	 	 	 ddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZdd Z dd!Z!dd"Z"dd#Z#dd$Z$dd%Z%dd&Z&dd'Z'dd(Z(dd)Z)dd*Z*dd+Z+dd,Z,dd-Z-dd.Z.dd/Z/dd0Z0dd1Z1dd2Z2dd3Z3dd4Z4dd5Z5dd6Z6dd7Z7dd8Z8dd9Z9dd:Z:dd;Z;dd<Z<dd=Z=dd>Z>dd?Z?	 	 	 	 	 	 	 	 dd@Z@ddAZAddBZBddCZCddDZD	 	 	 	 	 	 	 	 	 	 ddEZEddFZFddGZGddHZHddIZI	 	 	 	 	 	 	 	 	 	 ddJZJddKZKddLZLddMZMddNZN	 	 	 	 	 	 ddOZOddPZPddQZQddRZRddSZSddTZTddUZUddVZVddWZWddXZXddYZY	 	 	 	 	 	 	 	 	 	 ddZZZdd[Z[	 	 	 	 	 	 	 	 	 	 dd\Z\	 	 	 	 	 	 	 	 dd]Z]dd^Z^dd_Z_dd`Z`ddaZaddbZbddcZcdddZdddeZeddfZfddgZgddhZhddiZi	 	 	 	 	 	 	 	 ddjZjdddkZkdddlZlddmZmenddn       Zoenddo       Zpenddp       Zqenddq       Zrenddr       Zsendds       Ztyt)r<   )EvalSeries[EagerDataFrameT, EagerSeriesT]_callc                    y rA   rB   )rC   callevaluate_output_namesalias_output_namesimplementationversions         rF   __init__zEagerExpr.__init__   s     rI   c                $    | j                  |      S rA   )r   ri   s     rF   rk   zEagerExpr.__call__   s    zz"~rI   c                     y rA   rB   rm   s    rF   rp   z EagerExpr.__narwhals_namespace__   s    HKrI   c               D     | ||||j                   |j                        S )Nr   r   r   r   r^   _version)rr   funcr   r   rs   s        rF   _from_callablezEagerExpr._from_callable  s,     "71"22$$
 	
rI   c                R     | fdfdd j                   j                        S )Nc                
    gS rA   rB   _dfseriess    rF   <lambda>z(EagerExpr._from_series.<locals>.<lambda>  s	     rI   c                    j                   gS rA   r   r   s    rF   r  z(EagerExpr._from_series.<locals>.<lambda>  s    v{{m rI   r   r   )rr   r   s    `rF   _from_serieszEagerExpr._from_series  s)     ";#!11OO
 	
rI   c                     j                   d nfdnfdd fd} j                  | j                   j                   j                        S )Nc                F     |       D cg c]
  } |       c}S c c}w rA   rB   )output_namesx
alias_namecurrent_alias_output_namess     rF   r  z4EagerExpr._with_alias_output_names.<locals>.<lambda>"  s&    +El+S&&'JqM&  &s   c                :    | D cg c]
  } |       c}S c c}w rA   rB   )r  r  r	  s     rF   r  z4EagerExpr._with_alias_output_names.<locals>.<lambda>'  s    |'L!
1'L 'L   c                @   rKt         |        j                  |             d      D cg c]  \  }}|j                  |       c}}S t         |       j                  |       d      D cg c]  \  }}|j                  |       c}}S c c}}w c c}}w )NTstrict)zipr`   r   )rj   r   r   r   rC   s      rF   r   z0EagerExpr._with_alias_output_names.<locals>.func*  s    ! ),R*4+F+Fr+JK#)$ LL&  %(Hd99"=d% FD T" s   B5Br   rj   r   rX   zlist[EagerSeriesT])rb   	__class__r`   r^   r   )rC   r	  r   r   r
  s   `` @@rF   _with_alias_output_namesz"EagerExpr._with_alias_output_names  sp    %)%=%=" !  *5	
 M 		" ~~"&"="=1//MM  
 	
rI   Fr   c                   t        | j                  f||d|}| j                  || j                  | j                  |       S )a  Reuse 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_namer   r   r   rs   )r   _reuse_series_innerr   r`   rb   )rC   r  r   kwargsr   s        rF   _reuse_serieszEagerExpr._reuse_seriesC  s^     $$
#)
 	
 """&"="=#77	 # 
 	
rI   c                   i S rA   rB   )rC   r   s     rF   _reuse_series_extra_kwargsz$EagerExpr._reuse_series_extra_kwargs`  s	     	rI   c                    t        |d      S )Nrn   )hasattr)rr   objs     rF   _is_exprzEagerExpr._is_expre  s    s/00rI   c                  |j                         D ci c]*  \  }}|| j                  |      r|j                  |      n|, }}}t        |fi | j	                  |      |} | |      D cg c]#  }|r|j                   ||            n ||      % }	}| j                  |      d |	D        }}
t        d t        |
|d      D              rd|
 d}t        |      |	S c c}}w c c}w )Nr  c              3  4   K   | ]  }|j                     y wrA   r  ).0ss     rF   	<genexpr>z0EagerExpr._reuse_series_inner.<locals>.<genexpr>  s     5Jaff5J   c              3  ,   K   | ]  \  }}||k7    y wrA   rB   )r#  r   r   s      rF   r%  z0EagerExpr._reuse_series_inner.<locals>.<genexpr>  s      
)eTETM
s   Tr  ztSafety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues
Expression aliases: 
)
itemsr   _evaluate_single_output_exprr   r  _from_scalarr   r   r  re   )rC   rj   r  r   r  r   rL   methodr   outaliasesr   rf   s                rF   r  zEagerExpr._reuse_series_inneri  s*     &||~	
 e }}U# 11%8
 
 
--^-L
 
 r('
 4BFv/vf~U'
 '
 //35Jc5J 
-0%-M
 
''.ir3  !%%
1
'
s   /C#.(C)c                n     d fd} j                  | j                   j                         S )a  Reuse 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           
        j                         D ci c]*  \  }}|j                  |      r| j                  |      n|, }}} |       D cg c]  } t        t        |            di |  c}S c c}}w c c}w )NrB   )r)  r   r*  getattr)	rj   r   rL   r  r   expressifiable_argsr  rC   series_namespaces	        rF   innerz0EagerExpr._reuse_series_namespace.<locals>.inner  s    
 $7#<#<#>	  D% ==' 55e<F  #2h H(89;GQ&Q s   /A7#A=r  r  r   r`   rb   )rC   r3  r  r2  r4  s   ```` rF   _reuse_series_namespacez!EagerExpr._reuse_series_namespace  s?    $
	 
	 """&"="=#77	 # 
 	
rI   c                     d fd} t               | j                   j                   j                   j                        S )Nc                V    g } |       D ]  }d|_         |j                  |        |S )NT)
_broadcastappend)rj   resultsresultrC   s      rF   r   z!EagerExpr.broadcast.<locals>.func  s6    Gr( '$(!v&' NrI   r   r  )typer`   rb   r^   r   rC   r   s   ` rF   r|   zEagerExpr.broadcast  sB    	 tDz"&"="=#77//MM
 	
rI   c                (    | j                  d|      S )Ncast)dtyper  )rC   rA  s     rF   r@  zEagerExpr.cast  s    !!&!66rI   c               (    | j                  ||      S )NotherrB  rC   operatorrE  s      rF   _with_binaryzEagerExpr._with_binary  s    !!(%!88rI   c               F    | j                  d      j                  ||      S )NliteralrD  )r   r  rF  s      rF   _with_binary_rightzEagerExpr._with_binary_right  s!    zz)$22852IIrI   c                &    | j                  d|      S )NrU   rH  rC   rE  s     rF   rU   zEagerExpr.__eq__        511rI   c                &    | j                  d|      S )NrW   rM  rN  s     rF   rW   zEagerExpr.__ne__  rO  rI   c                &    | j                  d|      S )NrQ   rM  rN  s     rF   rQ   zEagerExpr.__ge__  rO  rI   c                &    | j                  d|      S )NrM   rM  rN  s     rF   rM   zEagerExpr.__gt__  rO  rI   c                &    | j                  d|      S )NrS   rM  rN  s     rF   rS   zEagerExpr.__le__  rO  rI   c                &    | j                  d|      S )NrO   rM  rN  s     rF   rO   zEagerExpr.__lt__  rO  rI   c                &    | j                  d|      S )N__and__rM  rN  s     rF   rV  zEagerExpr.__and__        E22rI   c                &    | j                  d|      S )N__or__rM  rN  s     rF   rY  zEagerExpr.__or__  rO  rI   c                &    | j                  d|      S )N__add__rM  rN  s     rF   r[  zEagerExpr.__add__  rW  rI   c                &    | j                  d|      S )N__sub__rM  rN  s     rF   r]  zEagerExpr.__sub__  rW  rI   c                &    | j                  d|      S )N__rsub__rK  rN  s     rF   r_  zEagerExpr.__rsub__      &&z599rI   c                &    | j                  d|      S )N__mul__rM  rN  s     rF   rc  zEagerExpr.__mul__  rW  rI   c                &    | j                  d|      S )N__truediv__rM  rN  s     rF   re  zEagerExpr.__truediv__  s      66rI   c                &    | j                  d|      S )N__rtruediv__r`  rN  s     rF   rg  zEagerExpr.__rtruediv__  s    &&~u==rI   c                &    | j                  d|      S )N__floordiv__rM  rN  s     rF   ri  zEagerExpr.__floordiv__  s      77rI   c                &    | j                  d|      S )N__rfloordiv__r`  rN  s     rF   rk  zEagerExpr.__rfloordiv__  s    &&>>rI   c                &    | j                  d|      S )N__pow__rM  rN  s     rF   rm  zEagerExpr.__pow__  rW  rI   c                &    | j                  d|      S )N__rpow__r`  rN  s     rF   ro  zEagerExpr.__rpow__  ra  rI   c                &    | j                  d|      S )N__mod__rM  rN  s     rF   rq  zEagerExpr.__mod__  rW  rI   c                &    | j                  d|      S )N__rmod__r`  rN  s     rF   rs  zEagerExpr.__rmod__  ra  rI   c                $    | j                  d      S )N
__invert__rB  rm   s    rF   ru  zEagerExpr.__invert__	      !!,//rI   c                $    | j                  d      S )N__neg__rB  rm   s    rF   rx  zEagerExpr.__neg__      !!),,rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.null_count  s    !!,t!DDrI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.n_unique      !!*T!BBrI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.sum      !!%!==rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.count  s    !!'$!??rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.mean      !!&!>>rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.median  s    !!(4!@@rI   c               *    | j                  dd|      S )Nr   Tr   r   rB  r   s     rF   r   zEagerExpr.std"      !!%4!HHrI   c               *    | j                  dd|      S )Nr   Tr  rB  r   s     rF   r   zEagerExpr.var%  r  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.skew(  r  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.kurtosis+  r|  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.any.  r~  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.all1  r~  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.max4  r~  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.min7  r~  rI   c                (    | j                  dd      S )Narg_minTr  rB  rm   s    rF   r  zEagerExpr.arg_min:      !!)D!AArI   c                (    | j                  dd      S )Narg_maxTr  rB  rm   s    rF   r  zEagerExpr.arg_max=  r  rI   c                *    | j                  d||      S )Nclip)lower_boundupper_boundrB  )rC   r  r  s      rF   r  zEagerExpr.clipB  s!    !! " 
 	
rI   c                (    | j                  d|      S )N
clip_lower)r  rB  )rC   r  s     rF   r  zEagerExpr.clip_lowerG      !!,K!HHrI   c                (    | j                  d|      S )N
clip_upper)r  rB  )rC   r  s     rF   r  zEagerExpr.clip_upperJ  r  rI   c                $    | j                  d      S )Nis_nullrB  rm   s    rF   r  zEagerExpr.is_nullM  ry  rI   c                $    | j                  d      S )Nis_nanrB  rm   s    rF   r  zEagerExpr.is_nanP  s    !!(++rI   c                (    | j                  d|      S )Nfill_nan)rL   rB  rK   s     rF   r  zEagerExpr.fill_nanS  s    !!*E!::rI   c                ,    | j                  d|||      S )N	fill_null)rL   strategylimitrB  )rC   rL   r  r  s       rF   r  zEagerExpr.fill_nullV  s%     !!uxu " 
 	
rI   c                (    | j                  d|      S )Nis_inrD  rB  rN  s     rF   r  zEagerExpr.is_in]  s    !!'!77rI   c                $    | j                  d      S )Narg_truerB  rm   s    rF   r  zEagerExpr.arg_true`  s    !!*--rI   c                l    | j                         } |j                  |ddi}| j                  d|      S )Nr   Ffilter)	predicate)rp   all_horizontalr  )rC   
predicatesr   r  s       rF   r  zEagerExpr.filterc  s=    ))+&C&&
GG	!!(i!@@rI   c                $    | j                  d      S )N
drop_nullsrB  rm   s    rF   r  zEagerExpr.drop_nullsh  rv  rI   c               .    | j                  d||||      S )Nr   )r   r   r   r   rB  r   s        rF   r   zEagerExpr.replace_strictk  s'     !!#3l " 
 	
rI   c               *    | j                  d||      S )Nsort
descending
nulls_lastrB  rC   r  r  s      rF   r  zEagerExpr.sortw  s    !!&ZJ!WWrI   c                $    | j                  d      S )NabsrB  rm   s    rF   r  zEagerExpr.absz      !!%((rI   c                (    | j                  dd      S )NuniqueF)maintain_orderrB  rm   s    rF   r  zEagerExpr.unique}  s    !!(5!AArI   c                $    | j                  d      S )NdiffrB  rm   s    rF   r  zEagerExpr.diff      !!&))rI   c                    t        t        ||      d fd} j                  | j                   j                         S )N)nfractionwith_replacementc           	          |       D cg c]+  }|j                   |j                                     - c}S c c}w )N)height)r  r  seed)sampler   )rj   r    _resolve_sample_size_from_heightr  rC   r  s     rF   r   zEagerExpr.sample.<locals>.func  sM     #2h  6fjjlK%5    s   0?r  rj   r   rX   Sequence[EagerSeriesT])r   r   r   r`   rb   )rC   r  r  r  r  r   r  s   `  `` @rF   r  zEagerExpr.sample  sX     ,3 -	,
(	 	 """&"="=#77	 # 
 	
rI   c                     dfd} t                fd j                  | j                   j                        S )Nc                F    t        |       dk7  rd|  }t        |      gS N   z:Expected function with single output, found output names: )r   r#   r   rf   r   s     rF   r   z+EagerExpr.alias.<locals>.alias_output_names  s.    5zQRSXRYZ0556MrI   c                X     |       D cg c]  }|j                         c}S c c}w rA   r   )rj   r   r   rC   s     rF   r  z!EagerExpr.alias.<locals>.<lambda>  s"    bBvT*B Bs   'r   r   r   rX   r   )r=  r`   r^   r   )rC   r   r   s   `` rF   r   zEagerExpr.alias  s<    	 tDzB"&"="=1//MM
 	
rI   c                $    | j                  d      S )N	is_uniquerB  rm   s    rF   r  zEagerExpr.is_unique      !!+..rI   c                $    | j                  d      S )Nis_first_distinctrB  rm   s    rF   r  zEagerExpr.is_first_distinct  s    !!"566rI   c                $    | j                  d      S )Nis_last_distinctrB  rm   s    rF   r  zEagerExpr.is_last_distinct  s    !!"455rI   c                ,    | j                  dd||      S )Nr   T)r   r   r   rB  r   s      rF   r   zEagerExpr.quantile  s(     !!'	 " 
 	
rI   c                (    | j                  d|      S )Nheadr  rB  rC   r  s     rF   r  zEagerExpr.head      !!&A!..rI   c                (    | j                  d|      S )Ntailr  rB  r  s     rF   r  zEagerExpr.tail  r  rI   c                (    | j                  d|      S )Nround)decimalsrB  )rC   r  s     rF   r  zEagerExpr.round  s    !!'H!==rI   c                $    | j                  d      S )NfloorrB  rm   s    rF   r  zEagerExpr.floor  s    !!'**rI   c                $    | j                  d      S )NceilrB  rm   s    rF   r  zEagerExpr.ceil  r  rI   c                (    | j                  dd      S )Nr   Tr  rB  rm   s    rF   r   zEagerExpr.len  r~  rI   c                *    | j                  d||      S )Ngather_every)r  offsetrB  )rC   r  r  s      rF   r  zEagerExpr.gather_every  s    !!.Af!EErI   c               (    | j                  d|      S )Nmode)keeprB  )rC   r  s     rF   r  zEagerExpr.mode  s    !!&t!44rI   c                $    | j                  d      S )N	is_finiterB  rm   s    rF   r  zEagerExpr.is_finite  r  rI   c               ,    | j                  d|||      S )Nrolling_meanwindow_sizemin_samplescenterrB  rC   r  r  r  s       rF   r  zEagerExpr.rolling_mean  s&    !!##	 " 
 	
rI   c               .    | j                  d||||      S )Nrolling_stdr  r  r  r   rB  rC   r  r  r  r   s        rF   r  zEagerExpr.rolling_std  +     !!## " 
 	
rI   c               ,    | j                  d|||      S )Nrolling_sumr  rB  r  s       rF   r  zEagerExpr.rolling_sum  s$    !!{TZ " 
 	
rI   c               .    | j                  d||||      S )Nrolling_varr  rB  r  s        rF   r  zEagerExpr.rolling_var  r  rI   c               n     d fd} j                  | j                   j                         S )Nc                    |       }d |D        }t        fd|D              }|d   |d   }}t        ||d      }t        |      st        |      r,t	        |j
                        t        fd|D              }nIt        ||j                        rt        d |D              }n |j                  t        fd	|D              }t        fd
|D              }t        d |D              }sRt        |      rGt        |       dkD  r9|j                  d      }	t        ||	         }
dt        |
       d}t        |      |S )Nc              3  4   K   | ]  }|j                     y wrA   r  )r#  input_seriess     rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     P,L--Pr&  c              3  .   K   | ]  } |        y wrA   rB   )r#  r   r   s     rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     "P8F#3"Ps   r   Tr  )rs   c              3  R   K   | ]  \  }} |      j                  |         y wrA   r  )r#  arrout_name
from_numpys      rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s$     W=3z#44X>W   $'c              3  D   K   | ]  \  }}|j                  |        y wrA   r  )r#  r   r	  s      rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     Q:J&(v||H5Qs    c              3  R   K   | ]  \  }} |      j                  |         y wrA   r  )r#  valr	  from_scalars      rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s%     XMC{3/55h?Xr  c              3  @   K   | ]  }|j                          y wrA   )r@  )r#  r   r   s     rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     NVv{{<8Ns   c              3  8   K   | ]  }t        |      d k(    yw)r  N)r   )r#  rs     rF   r%  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>   s     $AQSVq[$As   r  zG`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"   r   r
  
isinstancer  r+  r   r   indexr=  r    	TypeError)rj   udf_series_inr  udf_series_out	_first_in
_first_outitr<  is_scalar_result_idx_typerf   r
  r  r   r   r   rC   s               @@rF   r   z#EagerExpr.map_batches.<locals>.func  sD    HMP-PL""P-"PPN$1!$4nQ6GzI ^\$?Bj)_Z-H$Y%9%94H
WTVWWJ	(;(;<QbQQ'44XUWXX'NvNN$$A&$AA",<(=3r7Q;'--d3^D121%89 :PP 
  n$MrI   r  r  r5  )rC   r   r   r   r   s   ```` rF   r   zEagerExpr.map_batches  s@    	 	@ """&"="=#77	 # 
 	
rI   c                (    | j                  d|      S )Nshiftr  rB  r  s     rF   r   zEagerExpr.shift3  s    !!'Q!//rI   c               (    | j                  d|      S )Ncum_sumreverserB  rC   r$  s     rF   r"  zEagerExpr.cum_sum6      !!)W!==rI   c               (    | j                  d|      S )N	cum_countr#  rB  r%  s     rF   r(  zEagerExpr.cum_count9  s    !!+w!??rI   c               (    | j                  d|      S )Ncum_minr#  rB  r%  s     rF   r*  zEagerExpr.cum_min<  r&  rI   c               (    | j                  d|      S )Ncum_maxr#  rB  r%  s     rF   r,  zEagerExpr.cum_max?  r&  rI   c               (    | j                  d|      S )Ncum_prodr#  rB  r%  s     rF   r.  zEagerExpr.cum_prodB  s    !!*g!>>rI   c               *    | j                  d||      S )Nrank)r,  r  rB  )rC   r,  r  s      rF   r0  zEagerExpr.rankE  s    !!&J!OOrI   c                (    | j                  d|      S )Nlog)baserB  )rC   r3  s     rF   r2  zEagerExpr.logH  s    !!%d!33rI   c                $    | j                  d      S )NexprB  rm   s    rF   r5  zEagerExpr.expK  r  rI   c                $    | j                  d      S )NsinrB  rm   s    rF   r7  zEagerExpr.sinN  r  rI   c                $    | j                  d      S )NcosrB  rm   s    rF   r9  zEagerExpr.cosQ  r  rI   c                $    | j                  d      S )NsqrtrB  rm   s    rF   r;  zEagerExpr.sqrtT  r  rI   c                ,    | j                  d|||      S )N
is_between)r  r  closedrB  )rC   r  r  r>  s       rF   r=  zEagerExpr.is_betweenW  s&     !!k{SY " 
 	
rI   c                     s j                  dd      S d fd} j                  | j                   j                         S )Nr   Tr  c                V     | j                   ddd}  j                         |       S NFr  )r  r   rj   r   rC   s    rF   r   zEagerExpr.first.<locals>.funcb  s*    (uGB4::<##rI   r  rj   r   rX   r   r  r   r`   rb   rC   r   r   s   `` rF   r   zEagerExpr.first^  sS    %%gd%CC	$ """&"="=#77	 # 
 	
rI   c                     s j                  dd      S d fd} j                  | j                   j                         S )Nr   Tr  c                V     | j                   ddd}  j                         |       S rA  )r  r   rB  s    rF   r   zEagerExpr.last.<locals>.funcq  s)    (uGB499;r?"rI   r  rC  rD  rE  s   `` rF   r   zEagerExpr.lastm  sS    %%fT%BB	# """&"="=#77	 # 
 	
rI   c               *    | j                  dd|      S )Nr   T)r   r   rB  r   s     rF   r   zEagerExpr.any_value|  s!    !!< " 
 	
rI   c                    t        |       S rA   )EagerExprCatNamespacerm   s    rF   catzEagerExpr.cat      $T**rI   c                    t        |       S rA   )EagerExprDateTimeNamespacerm   s    rF   dtzEagerExpr.dt  s    )$//rI   c                    t        |       S rA   )EagerExprListNamespacerm   s    rF   r   zEagerExpr.list      %d++rI   c                    t        |       S rA   )EagerExprNameNamespacerm   s    rF   r   zEagerExpr.name  rR  rI   c                    t        |       S rA   )EagerExprStringNamespacerm   s    rF   r   zEagerExpr.str      '--rI   c                    t        |       S rA   )EagerExprStructNamespacerm   s    rF   structzEagerExpr.struct  rW  rI   N)r   r   r   EvalNames[EagerDataFrameT]r   ra   r   r/   r   r0   rX   Noner  )rX   z=EagerNamespace[EagerDataFrameT, EagerSeriesT, Self, Any, Any])
r   r   r   r[  r   ra   rs   r1   rX   r&   )r   r   rX   r&   )r	  AliasName | NonerX   r&   )r  r   r   r   r  r   rX   r&   )r   r   rX   zdict[str, Any])r  z
Self | AnyrX   zTypeIs[Self])
rj   r   r  r   r   r   r  r   rX   r  )r3  z5Literal['cat', 'dt', 'list', 'name', 'str', 'struct']r  r   r2  r   rX   r&   r   )rA  r4   rX   r&   )rG  r   rE  r&   rX   r&   )rE  r&   rX   r&   r   )r  r&   r  r&   rX   r&   )r  r&   rX   r&   )r  r&   rX   r&   )rL   float | NonerX   r&   )rL   zSelf | Noner  zFillNullStrategy | Noner  
int | NonerX   r&   )rE  r   rX   r&   )r  r&   rX   r&   r   )r  r   r  r   rX   r&   )
r  r_  r  r^  r  r   r  r_  rX   r&   r   r   )r  r   rX   r&   )r  r   rX   r&   )r  r   r  r   rX   r&   )r  r5   rX   r&   )r  r   r  r   r  r   rX   r&   )
r  r   r  r   r  r   r   r   rX   r&   )r   zCallable[[Any], Any]r   r   r   r   rX   r&   )r$  r   rX   r&   )r,  r7   r  r   rX   r&   )r3  r   rX   r&   )r  r&   r  r&   r>  r2   rX   r&   r   r   r   )rX   zEagerExprCatNamespace[Self])rX   z EagerExprDateTimeNamespace[Self])rX   zEagerExprListNamespace[Self])rX   zEagerExprNameNamespace[Self])rX   zEagerExprStringNamespace[Self])rX   zEagerExprStructNamespace[Self])urY   rZ   r[   r   r   rk   rp   r   r   r  r  r  r  r   r  r6  r|   r@  rH  rK  rU   rW   rQ   rM   rS   rO   rV  rY  r[  r]  r_  rc  re  rg  ri  rk  rm  ro  rq  rs  ru  rx  r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  r   r  r  r  r   r  r  r  r  r  r   r  r  r  r  r  r  r  r   r   r"  r(  r*  r,  r.  r0  r2  r5  r7  r9  r;  r=  r   r   r   r   rK  rO  r   r   r   rZ  rB   rI   rF   r<   r<      s    547  :	
 . '  
L	FL 
7
  :	

 .
 !
 

 
  
 
%
P ;@

37
KN
	
< ).!%	
 1 1   	 
     
  D#
O#
 #
  #	#

 
#
J
&79J2222223233:37>8?3:3:0-EC>@?AII?C>>>>BB


II-,;
 
,C
LV
	
8.A
0

!

 

 	

 '

 


X)B* 
 
 	 

  
  
 
 
D
/76

.H
	
//>+*>F5/
	
	
03	
=A	
IL	
		


	
	
03	
=A	
IL	
		
,
&,
 ',

 ,
 
,
\0>@>>?P4)))*

.2
<J
	




 + + 0 0 , , , , . . . .rI   r<   c                  d    e Zd ZU ddZddZed	d       Z e       Z e       Z	 e       Z
ded<   y)
r=   c                    y rA   rB   r>  s     rF   r  z!LazyExpr._with_alias_output_names  rH   rI   c                2    dfd}| j                  |      S )Nc                F    t        |       dk7  rd|  }t        |      gS r  )r   
ValueErrorr  s     rF   r   zLazyExpr.alias.<locals>.fn  s-    5zQRSXRYZ o%6MrI   r  )r  )rC   r   r   s    ` rF   r   zLazyExpr.alias  s    	 ,,R00rI   c                    t        |       S rA   )LazyExprNameNamespacerm   s    rF   r   zLazyExpr.name  rL  rI   r   rK  N)r   ra   rX   r&   r   )rX   zLazyExprNameNamespace[Self])rY   rZ   r[   r  r   r   r   r   ewm_meanr   rK  r   rB   rI   rF   r=   r=     s@     P1 + +  H!#K*,C,rI   r=   c                  *    e Zd ZU ded<   edd       Zy)_ExprNamespacer   _compliant_exprc                    | j                   S rA   rj  rm   s    rF   	compliantz_ExprNamespace.compliant  s    ###rI   NrX   r   )rY   rZ   r[   r   r   rm  rB   rI   rF   ri  ri    s     '&$ $rI   ri  c                      e Zd ZddZy)EagerExprNamespacec                   || _         y rA   rl  rC   exprs     rF   r   zEagerExprNamespace.__init__  
    #rI   N)rs  r   rX   r\  rY   rZ   r[   r   rB   rI   rF   rp  rp        $rI   rp  c                      e Zd ZddZy)LazyExprNamespacec                   || _         y rA   rl  rr  s     rF   r   zLazyExprNamespace.__init__  rt  rI   N)rs  r   rX   r\  ru  rB   rI   rF   rx  rx    rv  rI   rx  c                      e Zd ZddZy)rJ  c                :    | j                   j                  dd      S )NrK  get_categoriesrm  r6  rm   s    rF   r|  z$EagerExprCatNamespace.get_categories  s    ~~55e=MNNrI   NrX   r   )rY   rZ   r[   r|  rB   rI   rF   rJ  rJ    s    OrI   rJ  c                      e Zd ZddZddZddZddZddZddZddZ	ddZ
dd	Zdd
ZddZddZddZddZddZddZddZddZddZddZddZddZddZy) rN  c                >    | j                   j                  dd|      S )NrO  	to_stringformatr}  rC   r  s     rF   r  z$EagerExprDateTimeNamespace.to_string  s    ~~55dKPV5WWrI   c                >    | j                   j                  dd|      S )NrO  replace_time_zone	time_zoner}  rC   r  s     rF   r  z,EagerExprDateTimeNamespace.replace_time_zone  &    ~~55% 6 
 	
rI   c                >    | j                   j                  dd|      S )NrO  convert_time_zoner  r}  r  s     rF   r  z,EagerExprDateTimeNamespace.convert_time_zone  r  rI   c                >    | j                   j                  dd|      S )NrO  	timestamp)	time_unitr}  )rC   r  s     rF   r  z$EagerExprDateTimeNamespace.timestamp  s%    ~~55+ 6 
 	
rI   c                :    | j                   j                  dd      S )NrO  dater}  rm   s    rF   r  zEagerExprDateTimeNamespace.date      ~~55dFCCrI   c                :    | j                   j                  dd      S )NrO  yearr}  rm   s    rF   r  zEagerExprDateTimeNamespace.year  r  rI   c                :    | j                   j                  dd      S )NrO  monthr}  rm   s    rF   r  z EagerExprDateTimeNamespace.month  s    ~~55dGDDrI   c                :    | j                   j                  dd      S )NrO  dayr}  rm   s    rF   r  zEagerExprDateTimeNamespace.day  s    ~~55dEBBrI   c                :    | j                   j                  dd      S )NrO  hourr}  rm   s    rF   r  zEagerExprDateTimeNamespace.hour  r  rI   c                :    | j                   j                  dd      S )NrO  minuter}  rm   s    rF   r  z!EagerExprDateTimeNamespace.minute      ~~55dHEErI   c                :    | j                   j                  dd      S )NrO  secondr}  rm   s    rF   r  z!EagerExprDateTimeNamespace.second  r  rI   c                :    | j                   j                  dd      S )NrO  millisecondr}  rm   s    rF   r  z&EagerExprDateTimeNamespace.millisecond      ~~55dMJJrI   c                :    | j                   j                  dd      S )NrO  microsecondr}  rm   s    rF   r  z&EagerExprDateTimeNamespace.microsecond  r  rI   c                :    | j                   j                  dd      S )NrO  
nanosecondr}  rm   s    rF   r  z%EagerExprDateTimeNamespace.nanosecond  s    ~~55dLIIrI   c                :    | j                   j                  dd      S )NrO  ordinal_dayr}  rm   s    rF   r  z&EagerExprDateTimeNamespace.ordinal_day  r  rI   c                :    | j                   j                  dd      S )NrO  weekdayr}  rm   s    rF   r  z"EagerExprDateTimeNamespace.weekday  s    ~~55dIFFrI   c                :    | j                   j                  dd      S )NrO  total_minutesr}  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_minutes      ~~55dOLLrI   c                :    | j                   j                  dd      S )NrO  total_secondsr}  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_seconds  r  rI   c                :    | j                   j                  dd      S )NrO  total_millisecondsr}  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_milliseconds      ~~55d<PQQrI   c                :    | j                   j                  dd      S )NrO  total_microsecondsr}  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_microseconds  r  rI   c                :    | j                   j                  dd      S )NrO  total_nanosecondsr}  rm   s    rF   r  z,EagerExprDateTimeNamespace.total_nanoseconds  s    ~~55d<OPPrI   c                >    | j                   j                  dd|      S )NrO  truncate)everyr}  )rC   r  s     rF   r  z#EagerExprDateTimeNamespace.truncate  s    ~~55dJe5TTrI   c                >    | j                   j                  dd|      S )NrO  	offset_bybyr}  rC   r  s     rF   r  z$EagerExprDateTimeNamespace.offset_by  s    ~~55dKB5OOrI   N)r  r   rX   r   )r  
str | NonerX   r   )r  r   rX   r   )r  r9   rX   r   r~  )r  r   rX   r   r  r   rX   r   )rY   rZ   r[   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   rI   rF   rN  rN    s    X





DDECDFFKKJKGMMRRQUPrI   rN  c                  \    e Zd ZddZddZddZddZddZddZddZ	ddZ
dd	Zdd
Zy)rQ  c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.len      ~~55feDDrI   c                :    | j                   j                  dd      S )Nr   r  r}  rm   s    rF   r  zEagerExprListNamespace.unique!      ~~55fhGGrI   c                >    | j                   j                  dd|      S )Nr   contains)itemr}  )rC   r  s     rF   r  zEagerExprListNamespace.contains$  s    ~~55fjt5TTrI   c                >    | j                   j                  dd|      S )Nr   get)r  r}  )rC   r  s     rF   r  zEagerExprListNamespace.get'  s    ~~55fe55QQrI   c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.min*  r  rI   c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.max-  r  rI   c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.mean0  s    ~~55ffEErI   c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.median3  r  rI   c                :    | j                   j                  dd      S )Nr   r   r}  rm   s    rF   r   zEagerExprListNamespace.sum6  r  rI   c               @    | j                   j                  dd||      S )Nr   r  r  r}  r  s      rF   r  zEagerExprListNamespace.sort9  s'    ~~55Fzj 6 
 	
rI   Nr~  )r  r6   rX   r   )r  r   rX   r   )r  r   r  r   rX   r   )rY   rZ   r[   r   r  r  r  r   r   r   r   r   r  rB   rI   rF   rQ  rQ    s=    EHUREEFHE
rI   rQ  c                  V    e Zd Zd
dZddZddZddZd
dZd
dZe	dd       Z
ddZy	)CompliantExprNameNamespacec                $    | j                  d       S rA   r   rm   s    rF   r  zCompliantExprNameNamespace.keepD  s    ""4((rI   c                $    | j                  |      S rA   r  )rC   r   s     rF   mapzCompliantExprNameNamespace.mapG  s    ""8,,rI   c                ,    | j                  fd      S )Nc                     |  S rA   rB   )r   prefixs    rF   r  z3CompliantExprNameNamespace.prefix.<locals>.<lambda>K  s    6(4&0A rI   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.prefixJ      ""#ABBrI   c                ,    | j                  fd      S )Nc                    |   S rA   rB   )r   suffixs    rF   r  z3CompliantExprNameNamespace.suffix.<locals>.<lambda>N  s    4&0A rI   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.suffixM  r  rI   c                @    | j                  t        j                        S rA   )r   r   lowerrm   s    rF   to_lowercasez'CompliantExprNameNamespace.to_lowercaseP      ""399--rI   c                @    | j                  t        j                        S rA   )r   r   upperrm   s    rF   to_uppercasez'CompliantExprNameNamespace.to_uppercaseS  r  rI   c                    d fd}|S )Nc               :    | D cg c]
  } |       c}S c c}w rA   rB   )r  r   r   s     rF   r   z:CompliantExprNameNamespace._alias_output_names.<locals>.fnX  s    +784DJ888r  )r  r   rX   r   rB   )r   r   s   ` rF   rb   z.CompliantExprNameNamespace._alias_output_namesV  s    	9 	rI   c                    y rA   rB   r>  s     rF   r   z)CompliantExprNameNamespace._from_callable]  rH   rI   Nrn  )r   r   rX   r   )r  r   rX   r   )r  r   rX   r   )r   r   rX   r   )r   r]  rX   r   )rY   rZ   r[   r  r  r  r  r  r  r   rb   r   rB   rI   rF   r  r  ?  s<    
)-CC..   RrI   r  c                      e Zd ZddZy)rT  c                <    | j                   }|j                  |      S rA   )rm  r  )rC   r   rs  s      rF   r   z%EagerExprNameNamespace._from_callablee  s    ~~,,T22rI   N)r   r]  rX   r   rY   rZ   r[   r   rB   rI   rF   rT  rT  `  s    
3rI   rT  c                      e Zd ZddZy)rf  c                f    | j                   }|r| j                  |      nd }|j                  |      S rA   )rm  rb   r  )rC   r   rs  r  s       rF   r   z$LazyExprNameNamespace._from_callableo  s0    ~~9=t//54,,\::rI   N)r   r]  rX   r   r  rB   rI   rF   rf  rf  j  s    
;rI   rf  c                      e Zd ZddZ	 	 	 	 	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZddZddZddZddZ	ddZ
dd	Zdd
ZddZddZddZddZddZddZdd dZdd dZy)!rV  c                :    | j                   j                  dd      S )Nr   	len_charsr}  rm   s    rF   r  z"EagerExprStringNamespace.len_charsx  s    ~~55e[IIrI   c               D    | j                   j                  dd||||      S )Nr   replace)patternrL   rJ  r  r}  )rC   rL   r  rJ  r  s        rF   r  z EagerExprStringNamespace.replace{  s-     ~~559gUGq 6 
 	
rI   c               B    | j                   j                  dd|||      S )Nr   replace_all)r  rL   rJ  r}  )rC   rL   r  rJ  s       rF   r  z$EagerExprStringNamespace.replace_all  s+     ~~55=' 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   strip_chars)
charactersr}  )rC   r  s     rF   r  z$EagerExprStringNamespace.strip_chars  s%    ~~55=Z 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   starts_with)r  r}  r  s     rF   r  z$EagerExprStringNamespace.starts_with      ~~55e]SY5ZZrI   c                >    | j                   j                  dd|      S )Nr   	ends_with)r  r}  r  s     rF   r  z"EagerExprStringNamespace.ends_with  s    ~~55e[QW5XXrI   c               @    | j                   j                  dd||      S )Nr   r  )r  rJ  r}  )rC   r  rJ  s      rF   r  z!EagerExprStringNamespace.contains  s'    ~~55:w 6 
 	
rI   c                @    | j                   j                  dd||      S )Nr   slice)r  lengthr}  )rC   r  r  s      rF   r  zEagerExprStringNamespace.slice  s'    ~~5576& 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   splitr  r}  r  s     rF   r  zEagerExprStringNamespace.split  s    ~~55eW5LLrI   c                >    | j                   j                  dd|      S )Nr   to_datetimer  r}  r  s     rF   r  z$EagerExprStringNamespace.to_datetime  r  rI   c                >    | j                   j                  dd|      S )Nr   to_dater  r}  r  s     rF   r  z EagerExprStringNamespace.to_date      ~~55eYv5VVrI   c                >    | j                   j                  dd|      S )Nr   to_timer  r}  r  s     rF   r  z EagerExprStringNamespace.to_time  r	  rI   c                :    | j                   j                  dd      S )Nr   r  r}  rm   s    rF   r  z%EagerExprStringNamespace.to_lowercase      ~~55e^LLrI   c                :    | j                   j                  dd      S )Nr   r  r}  rm   s    rF   r  z%EagerExprStringNamespace.to_uppercase  r  rI   c                >    | j                   j                  dd|      S )Nr   zfill)widthr}  )rC   r  s     rF   r  zEagerExprStringNamespace.zfill  s    ~~55eWE5RRrI   c                :    | j                   j                  dd      S )Nr   to_titlecaser}  rm   s    rF   r  z%EagerExprStringNamespace.to_titlecase  r  rI   c                @    | j                   j                  dd||      S )Nr   	pad_startr  	fill_charr}  rC   r  r  s      rF   r  z"EagerExprStringNamespace.pad_start  s'    ~~55;v 6 
 	
rI   c                @    | j                   j                  dd||      S )Nr   pad_endr  r}  r  s      rF   r  z EagerExprStringNamespace.pad_end  s'    ~~559Vy 6 
 	
rI   Nr~  )
rL   r   r  r   rJ  r   r  r   rX   r   )rL   r   r  r   rJ  r   rX   r   )r  r  rX   r   )r  r   rX   r   )r  r   rX   r   )r  r   rJ  r   rX   r   )r  r   r  r_  rX   r   r  )r  r  rX   r   )r  r   rX   r   ) )r  r   r  r   rX   r   )rY   rZ   r[   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   rI   rF   rV  rV  u  s    J

*-
;?
DG
	


*-
;?
	


[Y



M[WWMMSM


rI   rV  c                      e Zd ZddZy)rY  c                \    | j                   j                  dd|      j                  |      S )NrZ  fieldr  )rm  r6  r   r   s     rF   r  zEagerExprStructNamespace.field  s.    ~~55hd5SYY
 	
rI   N)r   r   rX   r   )rY   rZ   r[   r  rB   rI   rF   rY  rY    s    
rI   rY  N)Z
__future__r   	functoolsr   rG  r   typingr   r   r   r	   r
   !narwhals._compliant.any_namespacer   r   r   r   r   r   narwhals._compliant.columnr   narwhals._compliant.typingr   r   r   r   r   r   r   r   r   r   r   narwhals._utilsr   r   r   r    narwhals.dependenciesr!   r"   narwhals.exceptionsr#   collections.abcr$   r%   typing_extensionsr&   r'   narwhals._compliant.namespacer(   r)   narwhals._compliant.seriesr*   r+   r,   narwhals._expression_parsingr-   narwhals._typingr.   r/   r0   r1   narwhals.typingr2   r3   r4   r5   r6   r7   r8   r9   __all__r>   r:   r   r;   r<   r=   ri  rp  rx  rJ  rN  rQ  r  rT  rf  rV  rY  rB   rI   rF   <module>r0     s   "  ! A A  7     B :2.P:@9*HH	 	 	 X1 1*[/Xo/NNO[/|N/#BBC_==>N("B_==>_==>"BJl
.o|34_l*+l
.`- +-.9Lk9Y0Z-,$&'2C)D$$
3WZ5H $
$y1793E $
Oz"L$<gj>QOLPz"$5j$A7:CVLP^!
z"M*$=wz?R!
HR$%#$RB3z"z*J3;i y)I;I
z"OJ$?ATI
X
z"OJ$?AT
rI   