
    [i                    H   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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 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/ d dl0m1Z1m2Z2 d dlmZm3Z3 d dl4m5Z5 d dlmZ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 d0 d1ePe    eUe    e
e          ZV G d2 d3eQe"   eUe"   e
e"         ZW G d4 d5ePe    ee    e
e          ZX G d6 d7ePe    ee    e
e          ZYy8)9    )annotations)partial)methodcaller)TYPE_CHECKINGAnyCallableGenericLiteralProtocol)CatNamespaceDateTimeNamespaceListNamespaceNameNamespaceStringNamespaceStructNamespace)CompliantColumn)CompliantNamespace)	AliasName
AliasNamesCompliantExprT_coCompliantFrameTCompliantLazyFrameTCompliantSeriesOrNativeExprT_coEagerDataFrameT
EagerExprTEagerSeriesT	LazyExprTNativeExprT)_StoresCompliantnot_implementedqualified_type_name
zip_strict)is_numpy_arrayis_numpy_scalar)MultiOutputExpressionError)Sequence)SelfTypeIs)r   EagerNamespace)CompliantSeries)r   	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      i/var/www/html/userprofiledev.eatanceapp.com/venv/lib/python3.12/site-packages/narwhals/_compliant/expr.pybetweenzNativeExpr.betweenG   s    s    c                    y rA   rB   rC   values     rF   __gt__zNativeExpr.__gt__M       SrH   c                    y rA   rB   rJ   s     rF   __lt__zNativeExpr.__lt__N   rM   rH   c                    y rA   rB   rJ   s     rF   __ge__zNativeExpr.__ge__O   rM   rH   c                    y rA   rB   rJ   s     rF   __le__zNativeExpr.__le__P   rM   rH   c                    y rA   rB   rJ   s     rF   __eq__zNativeExpr.__eq__Q   rM   rH   c                    y rA   rB   rJ   s     rF   __ne__zNativeExpr.__ne__R   rM   rH   N)rD   r   rE   r   returnr   )rK   r   rX   r'   )__name__
__module____qualname____doc__rG   rL   rO   rQ   rS   rU   rW   rB   rH   rF   r>   r>   @   s      ; 100000rH   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d+dZd+dZd0dZd+dZd+dZd+dZd+dZd+dZd+dZd1d2dZd1d2dZd+dZd+dZd3dZd3d Zd+d!Zd+d"Zd+d#Z d4d$Z!	 	 	 	 	 	 d5d%Z"	 	 	 	 	 	 	 	 d6d&Z#	 	 	 	 	 	 	 	 	 	 d7d'Z$ed8d(       Z%y)9r:   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  !%%!!!rH   c                     y rA   rB   rC   dfs     rF   __call__zCompliantExpr.__call__m   s    47rH   c                    | S rA   rB   rC   s    rF   __narwhals_expr__zCompliantExpr.__narwhals_expr__p   s    rH   c                     y rA   rB   rm   s    rF   __narwhals_namespace__z$CompliantExpr.__narwhals_namespace__s   s    SVrH   c                    y rA   rB   )clscontextcolumn_indicess      rF   from_column_indicesz!CompliantExpr.from_column_indicest   s     rH   c                   y rA   rB   rr   evaluate_column_namesrs   s      rF   from_column_nameszCompliantExpr.from_column_namesx        rH   c                     y rA   rB   rm   s    rF   	broadcastzCompliantExpr.broadcast   s    rH   c                     y rA   rB   rC   names     rF   aliaszCompliantExpr.alias   s    rH   c                     y rA   rB   rm   s    rF   allzCompliantExpr.all       3rH   c                     y rA   rB   rm   s    rF   anyzCompliantExpr.any   r   rH   c                    y rA   rB   rC   ignore_nullss     rF   	any_valuezCompliantExpr.any_value   s    rH   c                     y rA   rB   rm   s    rF   countzCompliantExpr.count   s    SrH   c                     y rA   rB   rm   s    rF   minzCompliantExpr.min   r   rH   c                     y rA   rB   rm   s    rF   maxzCompliantExpr.max   r   rH   c                     y rA   rB   rm   s    rF   meanzCompliantExpr.mean       CrH   c                     y rA   rB   rm   s    rF   sumzCompliantExpr.sum   r   rH   c                     y rA   rB   rm   s    rF   medianzCompliantExpr.median   s    crH   c                     y rA   rB   rC   order_bys     rF   firstzCompliantExpr.first   s    3rH   c                     y rA   rB   r   s     rF   lastzCompliantExpr.last   s    #rH   c                     y rA   rB   rm   s    rF   skewzCompliantExpr.skew   r   rH   c                     y rA   rB   rm   s    rF   kurtosiszCompliantExpr.kurtosis       rH   c                    y rA   rB   rC   ddofs     rF   stdzCompliantExpr.std       rH   c                    y rA   rB   r   s     rF   varzCompliantExpr.var   r   rH   c                     y rA   rB   rm   s    rF   n_uniquezCompliantExpr.n_unique   r   rH   c                     y rA   rB   rm   s    rF   
null_countzCompliantExpr.null_count   s    #rH   c                     y rA   rB   rm   s    rF   lenzCompliantExpr.len   r   rH   c                     y rA   rB   )rC   partition_byr   s      rF   overzCompliantExpr.over   s    RUrH   c                     y rA   rB   rC   quantileinterpolations      rF   r   zCompliantExpr.quantile   s    rH   c                    y rA   rB   )rC   functionreturn_dtypereturns_scalars       rF   map_batcheszCompliantExpr.map_batches   s     rH   c                    y rA   rB   rC   defaultoldnewr   s        rF   replace_strictzCompliantExpr.replace_strict   rz   rH   c                     y rA   rB   rm   s    rF   r   zCompliantExpr.name   s    +.rH   )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   rB   rH   rF   r:   r:   U   s    $#66** *.M&-
" 
"8!8	28 W!,;	  9
 ! 
  % ,; !>=#,,#%U.H	K '
  
!  	 ' 
 . .rH   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5WLOW555s   !)rj   r   rX   r   rB   )r   r   s   ` rF   _eval_names_indiceszImplExpr._eval_names_indices   s    	6 	rH   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MrH   N)r   zSequence[int]rX   r_   )r   r   rX   r   )rY   rZ   r[   staticmethodr   r   rB   rH   rF   r   r      s      NrH   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   rH   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ArH   N)rr   z
type[Self]rx   r_   rs   r1   rX   r'   )rX   r   )rY   rZ   r[   r   ry   r   rB   rH   rF   r;   r;      s@     9
 ! 
 BrH   r;   c                     e Zd ZU ded<   	 	 	 	 	 	 	 	 	 	 	 	 dtdZdudZ	 	 dvdZe	 	 	 	 	 	 	 	 	 	 dwd       Zedxd       Z	dydZ
d	d
	 	 	 	 	 	 	 dzdZd	d
	 	 	 d{dZed|d       Z	 	 	 	 	 	 	 	 	 	 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'dd(Z(dd)Z)dd*Z*dd+Z+dd,Z,dd-Z-dd.Z.dd/Z/dd0Z0dd1Z1dd2Z2dd3Z3dd4Z4dd5Z5dd6Z6dd7Z7dd8Z8dd9Z9dd:Z:dd;Z;dd<Z<dd=Z=dd>Z>	 	 	 	 	 	 	 	 dd?Z?dd@Z@ddAZAddBZBddCZC	 	 	 	 	 	 	 	 	 	 ddDZDddEZEddFZFddGZGddHZH	 	 	 	 	 	 	 	 	 	 ddIZIddJZJddKZKddLZLddMZM	 	 	 	 	 	 ddNZNddOZOddPZPddQZQddRZRddSZSddTZTddUZUddVZVddWZWddXZX	 	 	 	 	 	 	 	 	 	 ddYZYddZZZ	 	 	 	 	 	 	 	 	 	 dd[Z[	 	 	 	 	 	 	 	 dd\Z\dd]Z]dd^Z^dd_Z_dd`Z`ddaZaddbZbddcZcdddZdddeZeddfZfddgZgddhZh	 	 	 	 	 	 	 	 ddiZidddjZjdddkZkddlZlemddm       Znemddn       Zoemddo       Zpemddp       Zqemddq       Zremddr       Zsys)r<   )EvalSeries[EagerDataFrameT, EagerSeriesT]_callc                    y rA   rB   )rC   callevaluate_output_namesalias_output_namesimplementationversions         rF   __init__zEagerExpr.__init__   s     rH   c                $    | j                  |      S rA   )r   ri   s     rF   rk   zEagerExpr.__call__   s    zz"~rH   c                     y rA   rB   rm   s    rF   rp   z EagerExpr.__narwhals_namespace__   s    HKrH   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$$
 	
rH   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    rH   c                    j                   gS rA   r   r   s    rF   r  z(EagerExpr._from_series.<locals>.<lambda>  s    v{{mrH   r   r   )rr   r   s    `rF   _from_serieszEagerExpr._from_series  s)     ";#!11OO
 	
rH   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&+SaJqM+S& &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                8   rIt         |        j                  |                   D cg c]  \  }}|j                  |       c}}S t         |       j                  |             D cg c]  \  }}|j                  |       c}}S c c}}w c c}}w rA   )r"   r`   r   )rj   r   r   r   rC   s      rF   r   z0EagerExpr._with_alias_output_names.<locals>.func%  s    ! )3R"4T5P5PQS5T"U)) LL&)  %/tBx9T9TUW9X$Y$YLFD T"$Y s   B1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  
 	
rH   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_series:  s^     $$
#)
 	
 """&"="=#77	 # 
 	
rH   c                   i S rA   rB   )rC   r   s     rF   _reuse_series_extra_kwargsz$EagerExpr._reuse_series_extra_kwargsW  s	     	rH   c                    t        |d      S )Nrn   )hasattr)rr   objs     rF   _is_exprzEagerExpr._is_expr\  s    s/00rH   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              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>w  s     5Jcaffc   c              3  ,   K   | ]  \  }}||k7    y wrA   rB   )r   r   r   s      rF   r"  z0EagerExpr._reuse_series_inner.<locals>.<genexpr>x  s      
-GkeTETM-Gs   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   rK   methodr   outaliasesr   rf   s                rF   r  zEagerExpr._reuse_series_inner`  s0     &||~	
  .e }}U# 11%8  .	 	 
 
--^-L
 
 r('
" 4BFv/vf~U" 	 '
 //35Jc5J 
-7-G
 
''.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   rK   r  r   expressifiable_argsr  rC   series_namespaces	        rF   innerz0EagerExpr._reuse_series_namespace.<locals>.inner  s    
 $7#<#<#>	 $?KD% ==' 55e< $?	   #2h&F H(89;GQ&Q& s   /A7#A=r  r  r   r`   rb   )rC   r0  r  r/  r1  s   ```` rF   _reuse_series_namespacez!EagerExpr._reuse_series_namespace  s?    $
	 
	 """&"="=#77	 # 
 	
rH   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  s1    Gr($(!v& # NrH   r   r  )typer`   rb   r^   r   rC   r   s   ` rF   r|   zEagerExpr.broadcast  sB    	 tDz"&"="=#77//MM
 	
rH   c                (    | j                  d|      S )Ncast)dtyper  )rC   r>  s     rF   r=  zEagerExpr.cast  s    !!&!66rH   c               (    | j                  ||      S )Notherr?  rC   operatorrB  s      rF   _with_binaryzEagerExpr._with_binary  s    !!(%!88rH   c               F    | j                  d      j                  ||      S )NliteralrA  )r   r  rC  s      rF   _with_binary_rightzEagerExpr._with_binary_right  s!    zz)$22852IIrH   c                &    | j                  d|      S )NrU   rE  rC   rB  s     rF   rU   zEagerExpr.__eq__        511rH   c                &    | j                  d|      S )NrW   rJ  rK  s     rF   rW   zEagerExpr.__ne__  rL  rH   c                &    | j                  d|      S )NrQ   rJ  rK  s     rF   rQ   zEagerExpr.__ge__  rL  rH   c                &    | j                  d|      S )NrL   rJ  rK  s     rF   rL   zEagerExpr.__gt__  rL  rH   c                &    | j                  d|      S )NrS   rJ  rK  s     rF   rS   zEagerExpr.__le__  rL  rH   c                &    | j                  d|      S )NrO   rJ  rK  s     rF   rO   zEagerExpr.__lt__  rL  rH   c                &    | j                  d|      S )N__and__rJ  rK  s     rF   rS  zEagerExpr.__and__        E22rH   c                &    | j                  d|      S )N__or__rJ  rK  s     rF   rV  zEagerExpr.__or__  rL  rH   c                &    | j                  d|      S )N__add__rJ  rK  s     rF   rX  zEagerExpr.__add__  rT  rH   c                &    | j                  d|      S )N__sub__rJ  rK  s     rF   rZ  zEagerExpr.__sub__  rT  rH   c                &    | j                  d|      S )N__rsub__rH  rK  s     rF   r\  zEagerExpr.__rsub__      &&z599rH   c                &    | j                  d|      S )N__mul__rJ  rK  s     rF   r`  zEagerExpr.__mul__  rT  rH   c                &    | j                  d|      S )N__truediv__rJ  rK  s     rF   rb  zEagerExpr.__truediv__  s      66rH   c                &    | j                  d|      S )N__rtruediv__r]  rK  s     rF   rd  zEagerExpr.__rtruediv__  s    &&~u==rH   c                &    | j                  d|      S )N__floordiv__rJ  rK  s     rF   rf  zEagerExpr.__floordiv__  s      77rH   c                &    | j                  d|      S )N__rfloordiv__r]  rK  s     rF   rh  zEagerExpr.__rfloordiv__  s    &&>>rH   c                &    | j                  d|      S )N__pow__rJ  rK  s     rF   rj  zEagerExpr.__pow__  rT  rH   c                &    | j                  d|      S )N__rpow__r]  rK  s     rF   rl  zEagerExpr.__rpow__  r^  rH   c                &    | j                  d|      S )N__mod__rJ  rK  s     rF   rn  zEagerExpr.__mod__  rT  rH   c                &    | j                  d|      S )N__rmod__r]  rK  s     rF   rp  zEagerExpr.__rmod__  r^  rH   c                $    | j                  d      S )N
__invert__r?  rm   s    rF   rr  zEagerExpr.__invert__       !!,//rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.null_count  s    !!,t!DDrH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.n_unique      !!*T!BBrH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.sum
      !!%!==rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.count  s    !!'$!??rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.mean      !!&!>>rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.median  s    !!(4!@@rH   c               *    | j                  dd|      S )Nr   Tr   r   r?  r   s     rF   r   zEagerExpr.std      !!%4!HHrH   c               *    | j                  dd|      S )Nr   Tr~  r?  r   s     rF   r   zEagerExpr.var  r  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.skew  r{  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.kurtosis  rv  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.any"  rx  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.all%  rx  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.max(  rx  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.min+  rx  rH   c                (    | j                  dd      S )Narg_minTr  r?  rm   s    rF   r  zEagerExpr.arg_min.      !!)D!AArH   c                (    | j                  dd      S )Narg_maxTr  r?  rm   s    rF   r  zEagerExpr.arg_max1  r  rH   c                *    | j                  d||      S )Nclip)lower_boundupper_boundr?  )rC   r  r  s      rF   r  zEagerExpr.clip6  s!    !! " 
 	
rH   c                (    | j                  d|      S )N
clip_lower)r  r?  )rC   r  s     rF   r  zEagerExpr.clip_lower;      !!,K!HHrH   c                (    | j                  d|      S )N
clip_upper)r  r?  )rC   r  s     rF   r  zEagerExpr.clip_upper>  r  rH   c                $    | j                  d      S )Nis_nullr?  rm   s    rF   r  zEagerExpr.is_nullA  s    !!),,rH   c                $    | j                  d      S )Nis_nanr?  rm   s    rF   r  zEagerExpr.is_nanD  s    !!(++rH   c                (    | j                  d|      S )Nfill_nan)rK   r?  rJ   s     rF   r  zEagerExpr.fill_nanG  s    !!*E!::rH   c                ,    | j                  d|||      S )N	fill_null)rK   strategylimitr?  )rC   rK   r  r  s       rF   r  zEagerExpr.fill_nullJ  s%     !!uxu " 
 	
rH   c                (    | j                  d|      S )Nis_inrA  r?  rK  s     rF   r  zEagerExpr.is_inQ  s    !!'!77rH   c                $    | j                  d      S )Narg_truer?  rm   s    rF   r  zEagerExpr.arg_trueT  s    !!*--rH   c                l    | j                         } |j                  |ddi}| j                  d|      S )Nr   Ffilter)	predicate)rp   all_horizontalr  )rC   
predicatesplxr  s       rF   r  zEagerExpr.filterW  s=    ))+&C&&
GG	!!(i!@@rH   c                $    | j                  d      S )N
drop_nullsr?  rm   s    rF   r  zEagerExpr.drop_nulls\  rs  rH   c               .    | j                  d||||      S )Nr   )r   r   r   r   r?  r   s        rF   r   zEagerExpr.replace_strict_  s'     !!#3l " 
 	
rH   c               *    | j                  d||      S )Nsort
descending
nulls_lastr?  rC   r  r  s      rF   r  zEagerExpr.sortk  s    !!&ZJ!WWrH   c                $    | j                  d      S )Nabsr?  rm   s    rF   r  zEagerExpr.absn      !!%((rH   c                (    | j                  dd      S )NuniqueF)maintain_orderr?  rm   s    rF   r  zEagerExpr.uniqueq  s    !!(5!AArH   c                $    | j                  d      S )Ndiffr?  rm   s    rF   r  zEagerExpr.difft      !!&))rH   c               .    | j                  d||||      S )Nsample)nfractionwith_replacementseedr?  )rC   r  r  r  r  s        rF   r  zEagerExpr.samplew  s)     !!H?OVZ " 
 	
rH   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6MrH   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Bv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
 	
rH   c                $    | j                  d      S )N	is_uniquer?  rm   s    rF   r  zEagerExpr.is_unique      !!+..rH   c                $    | j                  d      S )Nis_first_distinctr?  rm   s    rF   r  zEagerExpr.is_first_distinct  s    !!"566rH   c                $    | j                  d      S )Nis_last_distinctr?  rm   s    rF   r  zEagerExpr.is_last_distinct  s    !!"455rH   c                ,    | j                  dd||      S )Nr   T)r   r   r   r?  r   s      rF   r   zEagerExpr.quantile  s(     !!'	 " 
 	
rH   c                (    | j                  d|      S )Nheadr  r?  rC   r  s     rF   r  zEagerExpr.head      !!&A!..rH   c                (    | j                  d|      S )Ntailr  r?  r  s     rF   r  zEagerExpr.tail  r  rH   c                (    | j                  d|      S )Nround)decimalsr?  )rC   r  s     rF   r  zEagerExpr.round  s    !!'H!==rH   c                $    | j                  d      S )Nfloorr?  rm   s    rF   r  zEagerExpr.floor  s    !!'**rH   c                $    | j                  d      S )Nceilr?  rm   s    rF   r  zEagerExpr.ceil  r  rH   c                (    | j                  dd      S )Nr   Tr  r?  rm   s    rF   r   zEagerExpr.len  rx  rH   c                *    | j                  d||      S )Ngather_every)r  offsetr?  )rC   r  r  s      rF   r  zEagerExpr.gather_every  s    !!.Af!EErH   c               (    | j                  d|      S )Nmode)keepr?  )rC   r  s     rF   r  zEagerExpr.mode  s    !!&t!44rH   c                $    | j                  d      S )N	is_finiter?  rm   s    rF   r  zEagerExpr.is_finite  r  rH   c               ,    | j                  d|||      S )Nrolling_meanwindow_sizemin_samplescenterr?  rC   r  r  r  s       rF   r  zEagerExpr.rolling_mean  s&    !!##	 " 
 	
rH   c               .    | j                  d||||      S )Nrolling_stdr  r  r  r   r?  rC   r  r  r  r   s        rF   r  zEagerExpr.rolling_std  +     !!## " 
 	
rH   c               ,    | j                  d|||      S )Nrolling_sumr  r?  r  s       rF   r  zEagerExpr.rolling_sum  s$    !!{TZ " 
 	
rH   c               .    | j                  d||||      S )Nrolling_varr  r?  r  s        rF   r  zEagerExpr.rolling_var  r  rH   c               n     d fd} j                  | j                   j                         S )Nc                    |       }d |D        }t        fd|D              }|d   |d   }}t        ||      }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---r#  c              3  .   K   | ]  } |        y wrA   rB   )r   r   r   s     rF   r"  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     "P-8F#3-s   r   )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'     WTV=3z#44X>TV   $'c              3  D   K   | ]  \  }}|j                  |        y wrA   r  )r   r   r  s      rF   r"  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     Qb:J&(v||H5bs    c              3  R   K   | ]  \  }} |      j                  |         y wrA   r  )r   valr  from_scalars      rF   r"  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s(     XUWMC{3/55h?UWr  c              3  @   K   | ]  }|j                          y wrA   )r=  )r   r   r   s     rF   r"  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     NvVv{{<8vs   c              3  8   K   | ]  }t        |      d k(    yw)r  N)r   )r   rs     rF   r"  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     $A&QSVq[&s   r  TzG`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itr9  is_scalar_result_idx_typerf   r   r  r   r   r   rC   s               @@rF   r   z#EagerExpr.map_batches.<locals>.func  sB    HMP-PL""P-"PPN$1!$4nQ6GzI NL9B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$MrH   r  rj   r   rX   Sequence[EagerSeriesT]r2  )rC   r   r   r   r   s   ```` rF   r   zEagerExpr.map_batches  s@    	 	@ """&"="=#77	 # 
 	
rH   c                (    | j                  d|      S )Nshiftr  r?  r  s     rF   r  zEagerExpr.shift  s    !!'Q!//rH   c               (    | j                  d|      S )Ncum_sumreverser?  rC   r  s     rF   r  zEagerExpr.cum_sum      !!)W!==rH   c               (    | j                  d|      S )N	cum_countr  r?  r  s     rF   r   zEagerExpr.cum_count  s    !!+w!??rH   c               (    | j                  d|      S )Ncum_minr  r?  r  s     rF   r"  zEagerExpr.cum_min  r  rH   c               (    | j                  d|      S )Ncum_maxr  r?  r  s     rF   r$  zEagerExpr.cum_max  r  rH   c               (    | j                  d|      S )Ncum_prodr  r?  r  s     rF   r&  zEagerExpr.cum_prod   s    !!*g!>>rH   c               *    | j                  d||      S )Nrank)r)  r  r?  )rC   r)  r  s      rF   r(  zEagerExpr.rank#  s    !!&J!OOrH   c                (    | j                  d|      S )Nlog)baser?  )rC   r+  s     rF   r*  zEagerExpr.log&  s    !!%d!33rH   c                $    | j                  d      S )Nexpr?  rm   s    rF   r-  zEagerExpr.exp)  r  rH   c                $    | j                  d      S )Nsinr?  rm   s    rF   r/  zEagerExpr.sin,  r  rH   c                $    | j                  d      S )Ncosr?  rm   s    rF   r1  zEagerExpr.cos/  r  rH   c                $    | j                  d      S )Nsqrtr?  rm   s    rF   r3  zEagerExpr.sqrt2  r  rH   c                ,    | j                  d|||      S )N
is_between)r  r  closedr?  )rC   r  r  r6  s       rF   r5  zEagerExpr.is_between5  s&     !!k{SY " 
 	
rH   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>.func@  s*    (uGB4::<##rH   r  rj   r   rX   r   r  r   r`   rb   rC   r   r   s   `` rF   r   zEagerExpr.first<  sS    %%gd%CC	$ """&"="=#77	 # 
 	
rH   c                     s j                  dd      S d fd} j                  | j                   j                         S )Nr   Tr  c                V     | j                   ddd}  j                         |       S r9  )r  r   r:  s    rF   r   zEagerExpr.last.<locals>.funcO  s)    (uGB499;r?"rH   r  r;  r<  r=  s   `` rF   r   zEagerExpr.lastK  sS    %%fT%BB	# """&"="=#77	 # 
 	
rH   c               *    | j                  dd|      S )Nr   T)r   r   r?  r   s     rF   r   zEagerExpr.any_valueZ  s!    !!< " 
 	
rH   c                    t        |       S rA   )EagerExprCatNamespacerm   s    rF   catzEagerExpr.cat_      $T**rH   c                    t        |       S rA   )EagerExprDateTimeNamespacerm   s    rF   dtzEagerExpr.dtc  s    )$//rH   c                    t        |       S rA   )EagerExprListNamespacerm   s    rF   r   zEagerExpr.listg      %d++rH   c                    t        |       S rA   )EagerExprNameNamespacerm   s    rF   r   zEagerExpr.namek  rJ  rH   c                    t        |       S rA   )EagerExprStringNamespacerm   s    rF   r   zEagerExpr.stro      '--rH   c                    t        |       S rA   )EagerExprStructNamespacerm   s    rF   structzEagerExpr.structs  rO  rH   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   rS  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  )r0  z5Literal['cat', 'dt', 'list', 'name', 'str', 'struct']r  r   r/  r   rX   r'   r   )r>  r4   rX   r'   )rD  r   rB  r'   rX   r'   )rB  r'   rX   r'   r   )r  r'   r  r'   rX   r'   )r  r'   rX   r'   )r  r'   rX   r'   )rK   float | NonerX   r'   )rK   zSelf | Noner  zFillNullStrategy | Noner  
int | NonerX   r'   )rB  r   rX   r'   )r  r'   rX   r'   r   )r  r   r  r   rX   r'   )
r  rW  r  rV  r  r   r  rW  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'   )r+  r   rX   r'   )r  r'   r  r'   r6  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])trY   rZ   r[   r   r   rk   rp   r   r   r  r  r  r  r  r  r3  r|   r=  rE  rH  rU   rW   rQ   rL   rS   rO   rS  rV  rX  rZ  r\  r`  rb  rd  rf  rh  rj  rl  rn  rp  rr  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&  r(  r*  r-  r/  r1  r3  r5  r   r   r   r   rC  rG  r   r   r   rR  rB   rH   rF   r<   r<      s     547  :	
 . '  
L	FL 
7
  :	

 .
 !
 

 
  
 
!
H ;@

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*



 	


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

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

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

 + + 0 0 , , , , . . . .rH   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|  s    CrH   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%6MrH   r  )r  )rC   r   r   s    ` rF   r   zLazyExpr.alias}  s    	 ,,R00rH   c                    t        |       S rA   )LazyExprNameNamespacerm   s    rF   r   zLazyExpr.name  rD  rH   r    rC  N)r   ra   rX   r'   r   )rX   zLazyExprNameNamespace[Self])rY   rZ   r[   r  r   r   r   r    ewm_meanr   rC  r   rB   rH   rF   r=   r=   y  s@     P1 + +  H!#K*,C,rH   r=   c                  *    e Zd ZU ded<   edd       Zy)_ExprNamespacer   _compliant_exprc                    | j                   S rA   rb  rm   s    rF   	compliantz_ExprNamespace.compliant  s    ###rH   NrX   r   )rY   rZ   r[   r   r   re  rB   rH   rF   ra  ra    s     '&$ $rH   ra  c                      e Zd ZddZy)EagerExprNamespacec                   || _         y rA   rd  rC   exprs     rF   r   zEagerExprNamespace.__init__  
    #rH   N)rk  r   rX   rT  rY   rZ   r[   r   rB   rH   rF   rh  rh        $rH   rh  c                      e Zd ZddZy)LazyExprNamespacec                   || _         y rA   rd  rj  s     rF   r   zLazyExprNamespace.__init__  rl  rH   N)rk  r   rX   rT  rm  rB   rH   rF   rp  rp    rn  rH   rp  c                      e Zd ZddZy)rB  c                :    | j                   j                  dd      S )NrC  get_categoriesre  r3  rm   s    rF   rt  z$EagerExprCatNamespace.get_categories  s    ~~55e=MNNrH   NrX   r   )rY   rZ   r[   rt  rB   rH   rF   rB  rB    s    OrH   rB  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) rF  c                >    | j                   j                  dd|      S )NrG  	to_stringformatru  rC   r{  s     rF   ry  z$EagerExprDateTimeNamespace.to_string  s    ~~55dKPV5WWrH   c                >    | j                   j                  dd|      S )NrG  replace_time_zone	time_zoneru  rC   r  s     rF   r~  z,EagerExprDateTimeNamespace.replace_time_zone  &    ~~55% 6 
 	
rH   c                >    | j                   j                  dd|      S )NrG  convert_time_zoner  ru  r  s     rF   r  z,EagerExprDateTimeNamespace.convert_time_zone  r  rH   c                >    | j                   j                  dd|      S )NrG  	timestamp)	time_unitru  )rC   r  s     rF   r  z$EagerExprDateTimeNamespace.timestamp  s%    ~~55+ 6 
 	
rH   c                :    | j                   j                  dd      S )NrG  dateru  rm   s    rF   r  zEagerExprDateTimeNamespace.date      ~~55dFCCrH   c                :    | j                   j                  dd      S )NrG  yearru  rm   s    rF   r  zEagerExprDateTimeNamespace.year  r  rH   c                :    | j                   j                  dd      S )NrG  monthru  rm   s    rF   r  z EagerExprDateTimeNamespace.month  s    ~~55dGDDrH   c                :    | j                   j                  dd      S )NrG  dayru  rm   s    rF   r  zEagerExprDateTimeNamespace.day  s    ~~55dEBBrH   c                :    | j                   j                  dd      S )NrG  hourru  rm   s    rF   r  zEagerExprDateTimeNamespace.hour  r  rH   c                :    | j                   j                  dd      S )NrG  minuteru  rm   s    rF   r  z!EagerExprDateTimeNamespace.minute      ~~55dHEErH   c                :    | j                   j                  dd      S )NrG  secondru  rm   s    rF   r  z!EagerExprDateTimeNamespace.second  r  rH   c                :    | j                   j                  dd      S )NrG  millisecondru  rm   s    rF   r  z&EagerExprDateTimeNamespace.millisecond      ~~55dMJJrH   c                :    | j                   j                  dd      S )NrG  microsecondru  rm   s    rF   r  z&EagerExprDateTimeNamespace.microsecond  r  rH   c                :    | j                   j                  dd      S )NrG  
nanosecondru  rm   s    rF   r  z%EagerExprDateTimeNamespace.nanosecond  s    ~~55dLIIrH   c                :    | j                   j                  dd      S )NrG  ordinal_dayru  rm   s    rF   r  z&EagerExprDateTimeNamespace.ordinal_day  r  rH   c                :    | j                   j                  dd      S )NrG  weekdayru  rm   s    rF   r  z"EagerExprDateTimeNamespace.weekday  s    ~~55dIFFrH   c                :    | j                   j                  dd      S )NrG  total_minutesru  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_minutes      ~~55dOLLrH   c                :    | j                   j                  dd      S )NrG  total_secondsru  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_seconds  r  rH   c                :    | j                   j                  dd      S )NrG  total_millisecondsru  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_milliseconds      ~~55d<PQQrH   c                :    | j                   j                  dd      S )NrG  total_microsecondsru  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_microseconds  r  rH   c                :    | j                   j                  dd      S )NrG  total_nanosecondsru  rm   s    rF   r  z,EagerExprDateTimeNamespace.total_nanoseconds  s    ~~55d<OPPrH   c                >    | j                   j                  dd|      S )NrG  truncate)everyru  )rC   r  s     rF   r  z#EagerExprDateTimeNamespace.truncate  s    ~~55dJe5TTrH   c                >    | j                   j                  dd|      S )NrG  	offset_bybyru  rC   r  s     rF   r  z$EagerExprDateTimeNamespace.offset_by  s    ~~55dKB5OOrH   N)r{  r   rX   r   )r  
str | NonerX   r   )r  r   rX   r   )r  r9   rX   r   rv  )r  r   rX   r   r  r   rX   r   )rY   rZ   r[   ry  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   rH   rF   rF  rF    s    X





DDECDFFKKJKGMMRRQUPrH   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y)rI  c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.len      ~~55feDDrH   c                :    | j                   j                  dd      S )Nr   r  ru  rm   s    rF   r  zEagerExprListNamespace.unique      ~~55fhGGrH   c                >    | j                   j                  dd|      S )Nr   contains)itemru  )rC   r  s     rF   r  zEagerExprListNamespace.contains  s    ~~55fjt5TTrH   c                >    | j                   j                  dd|      S )Nr   get)r  ru  )rC   r  s     rF   r  zEagerExprListNamespace.get  s    ~~55fe55QQrH   c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.min  r  rH   c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.max  r  rH   c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.mean  s    ~~55ffEErH   c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.median  r  rH   c                :    | j                   j                  dd      S )Nr   r   ru  rm   s    rF   r   zEagerExprListNamespace.sum  r  rH   c               @    | j                   j                  dd||      S )Nr   r  r  ru  r  s      rF   r  zEagerExprListNamespace.sort  s'    ~~55Fzj 6 
 	
rH   Nrv  )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   rH   rF   rI  rI    s=    EHUREEFHE
rH   rI  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.keep"  s    ""4((rH   c                $    | j                  |      S rA   r  )rC   r   s     rF   mapzCompliantExprNameNamespace.map%  s    ""8,,rH   c                ,    | j                  fd      S )Nc                     |  S rA   rB   )r   prefixs    rF   r  z3CompliantExprNameNamespace.prefix.<locals>.<lambda>)  s    6(4&0ArH   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.prefix(      ""#ABBrH   c                ,    | j                  fd      S )Nc                    |   S rA   rB   )r   suffixs    rF   r  z3CompliantExprNameNamespace.suffix.<locals>.<lambda>,  s    4&0ArH   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.suffix+  r  rH   c                @    | j                  t        j                        S rA   )r   r   lowerrm   s    rF   to_lowercasez'CompliantExprNameNamespace.to_lowercase.      ""399--rH   c                @    | j                  t        j                        S rA   )r   r   upperrm   s    rF   to_uppercasez'CompliantExprNameNamespace.to_uppercase1  r  rH   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>.fn6  s    +78<4DJ<888r  )r  r   rX   r   rB   )r   r   s   ` rF   rb   z.CompliantExprNameNamespace._alias_output_names4  s    	9 	rH   c                    y rA   rB   r;  s     rF   r   z)CompliantExprNameNamespace._from_callable;  s    crH   Nrf  )r   r   rX   r   )r  r   rX   r   )r  r   rX   r   )r   r   rX   r   )r   rU  rX   r   )rY   rZ   r[   r  r  r  r  r  r  r   rb   r   rB   rH   rF   r  r    s<    
)-CC..   RrH   r  c                      e Zd ZddZy)rL  c                <    | j                   }|j                  |      S rA   )re  r  )rC   r   rk  s      rF   r   z%EagerExprNameNamespace._from_callableC  s    ~~,,T22rH   N)r   rU  rX   r   rY   rZ   r[   r   rB   rH   rF   rL  rL  >  s    
3rH   rL  c                      e Zd ZddZy)r^  c                f    | j                   }|r| j                  |      nd }|j                  |      S rA   )re  rb   r  )rC   r   rk  r  s       rF   r   z$LazyExprNameNamespace._from_callableM  s0    ~~9=t//54,,\::rH   N)r   rU  rX   r   r  rB   rH   rF   r^  r^  H  s    
;rH   r^  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dZdddZy) rN  c                :    | j                   j                  dd      S )Nr   	len_charsru  rm   s    rF   r  z"EagerExprStringNamespace.len_charsV  s    ~~55e[IIrH   c               D    | j                   j                  dd||||      S )Nr   replace)patternrK   rG  r  ru  )rC   rK   r  rG  r  s        rF   r  z EagerExprStringNamespace.replaceY  s-     ~~559gUGq 6 
 	
rH   c               B    | j                   j                  dd|||      S )Nr   replace_all)r  rK   rG  ru  )rC   rK   r  rG  s       rF   r  z$EagerExprStringNamespace.replace_all`  s+     ~~55=' 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   strip_chars)
charactersru  )rC   r  s     rF   r  z$EagerExprStringNamespace.strip_charsg  s%    ~~55=Z 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   starts_with)r  ru  r  s     rF   r  z$EagerExprStringNamespace.starts_withl      ~~55e]SY5ZZrH   c                >    | j                   j                  dd|      S )Nr   	ends_with)r  ru  r  s     rF   r  z"EagerExprStringNamespace.ends_witho  s    ~~55e[QW5XXrH   c               @    | j                   j                  dd||      S )Nr   r  )r  rG  ru  )rC   r  rG  s      rF   r  z!EagerExprStringNamespace.containsr  s'    ~~55:w 6 
 	
rH   c                @    | j                   j                  dd||      S )Nr   slice)r  lengthru  )rC   r  r  s      rF   r  zEagerExprStringNamespace.slicew  s'    ~~5576& 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   splitr  ru  r  s     rF   r  zEagerExprStringNamespace.split|  s    ~~55eW5LLrH   c                >    | j                   j                  dd|      S )Nr   to_datetimerz  ru  r|  s     rF   r  z$EagerExprStringNamespace.to_datetime  r  rH   c                >    | j                   j                  dd|      S )Nr   to_daterz  ru  r|  s     rF   r   z EagerExprStringNamespace.to_date  s    ~~55eYv5VVrH   c                :    | j                   j                  dd      S )Nr   r  ru  rm   s    rF   r  z%EagerExprStringNamespace.to_lowercase      ~~55e^LLrH   c                :    | j                   j                  dd      S )Nr   r  ru  rm   s    rF   r  z%EagerExprStringNamespace.to_uppercase  r  rH   c                >    | j                   j                  dd|      S )Nr   zfill)widthru  )rC   r  s     rF   r  zEagerExprStringNamespace.zfill  s    ~~55eWE5RRrH   c                :    | j                   j                  dd      S )Nr   to_titlecaseru  rm   s    rF   r  z%EagerExprStringNamespace.to_titlecase  r  rH   c                @    | j                   j                  dd||      S )Nr   	pad_startr  	fill_charru  rC   r  r  s      rF   r
  z"EagerExprStringNamespace.pad_start  s'    ~~55;v 6 
 	
rH   c                @    | j                   j                  dd||      S )Nr   pad_endr  ru  r  s      rF   r  z EagerExprStringNamespace.pad_end  s'    ~~559Vy 6 
 	
rH   Nrv  )
rK   r   r  r   rG  r   r  r   rX   r   )rK   r   r  r   rG  r   rX   r   )r  r  rX   r   )r  r   rX   r   )r  r   rX   r   )r  r   rG  r   rX   r   )r  r   r  rW  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  rB   rH   rF   rN  rN  S  s    J

*-
;?
DG
	


*-
;?
	


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



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


rH   rN  c                      e Zd ZddZy)rQ  c                \    | j                   j                  dd|      j                  |      S )NrR  fieldr  )re  r3  r   r~   s     rF   r  zEagerExprStructNamespace.field  s.    ~~55hd5SYY
 	
rH   N)r   r   rX   r   )rY   rZ   r[   r  rB   rH   rF   rQ  rQ    s    
rH   rQ  N)Z
__future__r   	functoolsr   rD  r   typingr   r   r   r	   r
   r   !narwhals._compliant.any_namespacer   r   r   r   r   r   narwhals._compliant.columnr   narwhals._compliant.namespacer   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&   typing_extensionsr'   r(   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=   ra  rh  rp  rB  rF  rI  r  rL  r^  rN  rQ  rB   rH   rF   <module>r%     s   "  ! K K  7 <     B :(.P:LL9*HH	 	 	 X1 1*U/Xo/NNOU/pN/#BBC_==>N("B_==>_==>"BJO
.o|34_l*+O
.f- +-.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;F
z"OJ$?ATF
R
z"OJ$?AT
rH   