
    /_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      W/var/www/html/land_sniper/venv/lib/python3.12/site-packages/narwhals/_compliant/expr.pybetweenzNativeExpr.betweenG           c                    y rA   rB   rC   values     rF   __gt__zNativeExpr.__gt__M   rH   rI   c                    y rA   rB   rK   s     rF   __lt__zNativeExpr.__lt__N   rH   rI   c                    y rA   rB   rK   s     rF   __ge__zNativeExpr.__ge__O   rH   rI   c                    y rA   rB   rK   s     rF   __le__zNativeExpr.__le__P   rH   rI   c                    y rA   rB   rK   s     rF   __eq__zNativeExpr.__eq__Q   rH   rI   c                    y rA   rB   rK   s     rF   __ne__zNativeExpr.__ne__R   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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d+dZd+dZd+dZd+dZd1dZd1d Zd+d!Zd+d"Zd+d#Z d2d$Z!	 	 	 	 	 	 d3d%Z"	 	 	 	 	 	 	 	 d4d&Z#	 	 	 	 	 	 	 	 	 	 d5d'Z$ed6d(       Z%y)7r:   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__m   s    47rI   c                    | S rA   rB   rC   s    rF   __narwhals_expr__zCompliantExpr.__narwhals_expr__p   s    rI   c                     y rA   rB   rm   s    rF   __narwhals_namespace__z$CompliantExpr.__narwhals_namespace__s   rH   rI   c                    y rA   rB   )clscontextcolumn_indicess      rF   from_column_indicesz!CompliantExpr.from_column_indicest   s     rI   c                   y rA   rB   rr   evaluate_column_namesrs   s      rF   from_column_nameszCompliantExpr.from_column_namesx        rI   c                     y rA   rB   rm   s    rF   	broadcastzCompliantExpr.broadcast   rH   rI   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   rm   s    rF   firstzCompliantExpr.first   rH   rI   c                     y rA   rB   rm   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_byorder_bys      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'   r   r   rX   r'   )r   Sequence[str]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   rI   rF   r:   r:   U   s    $#66** *.M&-
" 
"8!8	28 W!,;	  9
 ! 
  % ,; ! #,,#%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<   	 	 	 	 	 	 	 	 	 	 	 	 dsdZdtdZ	 	 dudZe	 	 	 	 	 	 	 	 	 	 dvd       Zedwd       Z	dxdZ
d	d
	 	 	 	 	 	 	 dydZd	d
	 	 	 dzdZed{d       Z	 	 	 	 	 	 	 	 	 	 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'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Zg	 	 	 	 	 	 	 	 ddhZhd~diZid~djZjddkZkelddl       Zmelddm       Znelddn       Zoelddo       Zpelddp       Zqelddq       Zryr)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                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 FD T" 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  
 	
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_series:  s^     $$
#)
 	
 """&"="=#77	 # 
 	
rI   c                   i S rA   rB   )rC   r   s     rF   _reuse_series_extra_kwargsz$EagerExpr._reuse_series_extra_kwargsW  s	     	rI   c                    t        |d      S )Nrn   )hasattr)rr   objs     rF   _is_exprzEagerExpr._is_expr\  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              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     5Jaff5J   c              3  ,   K   | ]  \  }}||k7    y wrA   rB   )r  r   r   s      rF   r  z0EagerExpr._reuse_series_inner.<locals>.<genexpr>x  s      
)eTETM
s   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_inner`  s(     &||~	
 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   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   r)  r  r(  r*  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   r7  s     rF   r6  zEagerExpr.cast  s    !!&!66rI   c               (    | j                  ||      S )Notherr8  rC   operatorr;  s      rF   _with_binaryzEagerExpr._with_binary  s    !!(%!88rI   c               F    | j                  d      j                  ||      S )Nliteralr:  )r   r  r<  s      rF   _with_binary_rightzEagerExpr._with_binary_right  s!    zz)$22852IIrI   c                &    | j                  d|      S )NrU   r>  rC   r;  s     rF   rU   zEagerExpr.__eq__        511rI   c                &    | j                  d|      S )NrW   rC  rD  s     rF   rW   zEagerExpr.__ne__  rE  rI   c                &    | j                  d|      S )NrQ   rC  rD  s     rF   rQ   zEagerExpr.__ge__  rE  rI   c                &    | j                  d|      S )NrM   rC  rD  s     rF   rM   zEagerExpr.__gt__  rE  rI   c                &    | j                  d|      S )NrS   rC  rD  s     rF   rS   zEagerExpr.__le__  rE  rI   c                &    | j                  d|      S )NrO   rC  rD  s     rF   rO   zEagerExpr.__lt__  rE  rI   c                &    | j                  d|      S )N__and__rC  rD  s     rF   rL  zEagerExpr.__and__        E22rI   c                &    | j                  d|      S )N__or__rC  rD  s     rF   rO  zEagerExpr.__or__  rE  rI   c                &    | j                  d|      S )N__add__rC  rD  s     rF   rQ  zEagerExpr.__add__  rM  rI   c                &    | j                  d|      S )N__sub__rC  rD  s     rF   rS  zEagerExpr.__sub__  rM  rI   c                &    | j                  d|      S )N__rsub__rA  rD  s     rF   rU  zEagerExpr.__rsub__      &&z599rI   c                &    | j                  d|      S )N__mul__rC  rD  s     rF   rY  zEagerExpr.__mul__  rM  rI   c                &    | j                  d|      S )N__truediv__rC  rD  s     rF   r[  zEagerExpr.__truediv__  s      66rI   c                &    | j                  d|      S )N__rtruediv__rV  rD  s     rF   r]  zEagerExpr.__rtruediv__  s    &&~u==rI   c                &    | j                  d|      S )N__floordiv__rC  rD  s     rF   r_  zEagerExpr.__floordiv__  s      77rI   c                &    | j                  d|      S )N__rfloordiv__rV  rD  s     rF   ra  zEagerExpr.__rfloordiv__  s    &&>>rI   c                &    | j                  d|      S )N__pow__rC  rD  s     rF   rc  zEagerExpr.__pow__  rM  rI   c                &    | j                  d|      S )N__rpow__rV  rD  s     rF   re  zEagerExpr.__rpow__  rW  rI   c                &    | j                  d|      S )N__mod__rC  rD  s     rF   rg  zEagerExpr.__mod__  rM  rI   c                &    | j                  d|      S )N__rmod__rV  rD  s     rF   ri  zEagerExpr.__rmod__  rW  rI   c                $    | j                  d      S )N
__invert__r8  rm   s    rF   rk  zEagerExpr.__invert__       !!,//rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.null_count  s    !!,t!DDrI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.n_unique      !!*T!BBrI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.sum
      !!%!==rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.count      !!'$!??rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.mean      !!&!>>rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.median  s    !!(4!@@rI   c               *    | j                  dd|      S )Nr   Tr   r   r8  r   s     rF   r   zEagerExpr.std      !!%4!HHrI   c               *    | j                  dd|      S )Nr   Trx  r8  r   s     rF   r   zEagerExpr.var  ry  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.skew  ru  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.kurtosis  ro  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.any"  rq  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.all%  rq  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.max(  rq  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.min+  rq  rI   c                (    | j                  dd      S )Narg_minTr
  r8  rm   s    rF   r  zEagerExpr.arg_min.      !!)D!AArI   c                (    | j                  dd      S )Narg_maxTr
  r8  rm   s    rF   r  zEagerExpr.arg_max1  r  rI   c                *    | j                  d||      S )Nclip)lower_boundupper_boundr8  )rC   r  r  s      rF   r  zEagerExpr.clip6  s!    !! " 
 	
rI   c                (    | j                  d|      S )N
clip_lower)r  r8  )rC   r  s     rF   r  zEagerExpr.clip_lower;      !!,K!HHrI   c                (    | j                  d|      S )N
clip_upper)r  r8  )rC   r  s     rF   r  zEagerExpr.clip_upper>  r  rI   c                $    | j                  d      S )Nis_nullr8  rm   s    rF   r  zEagerExpr.is_nullA  s    !!),,rI   c                $    | j                  d      S )Nis_nanr8  rm   s    rF   r  zEagerExpr.is_nanD  s    !!(++rI   c                (    | j                  d|      S )Nfill_nan)rL   r8  rK   s     rF   r  zEagerExpr.fill_nanG  s    !!*E!::rI   c                ,    | j                  d|||      S )N	fill_null)rL   strategylimitr8  )rC   rL   r  r  s       rF   r  zEagerExpr.fill_nullJ  s%     !!uxu " 
 	
rI   c                (    | j                  d|      S )Nis_inr:  r8  rD  s     rF   r  zEagerExpr.is_inQ  s    !!'!77rI   c                $    | j                  d      S )Narg_truer8  rm   s    rF   r  zEagerExpr.arg_trueT  s    !!*--rI   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!@@rI   c                $    | j                  d      S )N
drop_nullsr8  rm   s    rF   r  zEagerExpr.drop_nulls\  rl  rI   c               .    | j                  d||||      S )Nr   )r   r   r   r   r8  r   s        rF   r   zEagerExpr.replace_strict_  s'     !!#3l " 
 	
rI   c               *    | j                  d||      S )Nsort
descending
nulls_lastr8  rC   r  r  s      rF   r  zEagerExpr.sortk  s    !!&ZJ!WWrI   c                $    | j                  d      S )Nabsr8  rm   s    rF   r  zEagerExpr.absn      !!%((rI   c                (    | j                  dd      S )NuniqueF)maintain_orderr8  rm   s    rF   r  zEagerExpr.uniqueq  s    !!(5!AArI   c                $    | j                  d      S )Ndiffr8  rm   s    rF   r  zEagerExpr.difft      !!&))rI   c               .    | j                  d||||      S )Nsample)nfractionwith_replacementseedr8  )rC   r  r  r  r  s        rF   r  zEagerExpr.samplew  s)     !!H?OVZ " 
 	
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   )r3  r`   r^   r   )rC   r   r   s   `` rF   r   zEagerExpr.alias  s<    	 tDzB"&"="=1//MM
 	
rI   c                $    | j                  d      S )N	is_uniquer8  rm   s    rF   r  zEagerExpr.is_unique      !!+..rI   c                $    | j                  d      S )Nis_first_distinctr8  rm   s    rF   r  zEagerExpr.is_first_distinct  s    !!"566rI   c                $    | j                  d      S )Nis_last_distinctr8  rm   s    rF   r  zEagerExpr.is_last_distinct  s    !!"455rI   c                ,    | j                  dd||      S )Nr   T)r   r   r   r8  r   s      rF   r   zEagerExpr.quantile  s(     !!'	 " 
 	
rI   c                (    | j                  d|      S )Nheadr  r8  rC   r  s     rF   r  zEagerExpr.head      !!&A!..rI   c                (    | j                  d|      S )Ntailr  r8  r  s     rF   r  zEagerExpr.tail  r  rI   c                (    | j                  d|      S )Nround)decimalsr8  )rC   r  s     rF   r  zEagerExpr.round  s    !!'H!==rI   c                $    | j                  d      S )Nfloorr8  rm   s    rF   r  zEagerExpr.floor  s    !!'**rI   c                $    | j                  d      S )Nceilr8  rm   s    rF   r  zEagerExpr.ceil  r  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.len  rq  rI   c                *    | j                  d||      S )Ngather_every)r  offsetr8  )rC   r  r  s      rF   r  zEagerExpr.gather_every  s    !!.Af!EErI   c               (    | j                  d|      S )Nmode)keepr8  )rC   r  s     rF   r  zEagerExpr.mode  s    !!&t!44rI   c                $    | j                  d      S )N	is_finiter8  rm   s    rF   r  zEagerExpr.is_finite  r  rI   c               ,    | j                  d|||      S )Nrolling_meanwindow_sizemin_samplescenterr8  rC   r  r  r  s       rF   r  zEagerExpr.rolling_mean  s&    !!##	 " 
 	
rI   c               .    | j                  d||||      S )Nrolling_stdr  r  r  r   r8  rC   r  r  r  r   s        rF   r  zEagerExpr.rolling_std  +     !!## " 
 	
rI   c               ,    | j                  d|||      S )Nrolling_sumr  r8  r  s       rF   r  zEagerExpr.rolling_sum  s$    !!{TZ " 
 	
rI   c               .    | j                  d||||      S )Nrolling_varr  r8  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        ||      }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   )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   )r6  )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  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   indexr3  r!   	TypeError)rj   udf_series_inr   udf_series_out	_first_in
_first_outitr2  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$MrI   r  rj   r   rX   Sequence[EagerSeriesT]r+  )rC   r   r   r   r   s   ```` rF   r   zEagerExpr.map_batches  s@    	 	@ """&"="=#77	 # 
 	
rI   c                (    | j                  d|      S )Nshiftr  r8  r  s     rF   r  zEagerExpr.shift  s    !!'Q!//rI   c               (    | j                  d|      S )Ncum_sumreverser8  rC   r  s     rF   r  zEagerExpr.cum_sum      !!)W!==rI   c               (    | j                  d|      S )N	cum_countr  r8  r  s     rF   r  zEagerExpr.cum_count  s    !!+w!??rI   c               (    | j                  d|      S )Ncum_minr  r8  r  s     rF   r  zEagerExpr.cum_min  r  rI   c               (    | j                  d|      S )Ncum_maxr  r8  r  s     rF   r  zEagerExpr.cum_max  r  rI   c               (    | j                  d|      S )Ncum_prodr  r8  r  s     rF   r   zEagerExpr.cum_prod   s    !!*g!>>rI   c               *    | j                  d||      S )Nrank)r"  r  r8  )rC   r"  r  s      rF   r"  zEagerExpr.rank#  s    !!&J!OOrI   c                (    | j                  d|      S )Nlog)baser8  )rC   r%  s     rF   r$  zEagerExpr.log&  s    !!%d!33rI   c                $    | j                  d      S )Nexpr8  rm   s    rF   r'  zEagerExpr.exp)  r  rI   c                $    | j                  d      S )Nsinr8  rm   s    rF   r)  zEagerExpr.sin,  r  rI   c                $    | j                  d      S )Nsqrtr8  rm   s    rF   r+  zEagerExpr.sqrt/  r  rI   c                ,    | j                  d|||      S )N
is_between)r  r  closedr8  )rC   r  r  r.  s       rF   r-  zEagerExpr.is_between2  s&     !!k{SY " 
 	
rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.first9  rs  rI   c                (    | j                  dd      S )Nr   Tr
  r8  rm   s    rF   r   zEagerExpr.last<  ru  rI   c               *    | j                  dd|      S )Nr   T)r   r   r8  r   s     rF   r   zEagerExpr.any_value?  s!    !!< " 
 	
rI   c                    t        |       S rA   )EagerExprCatNamespacerm   s    rF   catzEagerExpr.catD      $T**rI   c                    t        |       S rA   )EagerExprDateTimeNamespacerm   s    rF   dtzEagerExpr.dtH  s    )$//rI   c                    t        |       S rA   )EagerExprListNamespacerm   s    rF   r   zEagerExpr.listL      %d++rI   c                    t        |       S rA   )EagerExprNameNamespacerm   s    rF   r   zEagerExpr.nameP  r;  rI   c                    t        |       S rA   )EagerExprStringNamespacerm   s    rF   r   zEagerExpr.strT      '--rI   c                    t        |       S rA   )EagerExprStructNamespacerm   s    rF   structzEagerExpr.structX  r@  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   rD  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  )r)  z5Literal['cat', 'dt', 'list', 'name', 'str', 'struct']r  r   r(  r   rX   r'   r   )r7  r4   rX   r'   )r=  r   r;  r'   rX   r'   )r;  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'   )r;  r   rX   r'   )r  r'   rX   r'   r   )r  r   r  r   rX   r'   )
r  rH  r  rG  r  r   r  rH  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'   r.  r2   rX   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])srY   rZ   r[   r   r   rk   rp   r   r   r   r	  r  r  r  r  r,  r|   r6  r>  rA  rU   rW   rQ   rM   rS   rO   rL  rO  rQ  rS  rU  rY  r[  r]  r_  ra  rc  re  rg  ri  rk  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)  r+  r-  r   r   r   r   r4  r8  r   r   r   rC  rB   rI   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 , , , , . . . .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   r4  s     rF   r	  z!LazyExpr._with_alias_output_namesa  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>.fnc  s-    5zQRSXRYZ o%6MrI   r  )r	  )rC   r   r   s    ` rF   r   zLazyExpr.aliasb  s    	 ,,R00rI   c                    t        |       S rA   )LazyExprNameNamespacerm   s    rF   r   zLazyExpr.namek  r5  rI   r    r4  N)r   ra   rX   r'   r   )rX   zLazyExprNameNamespace[Self])rY   rZ   r[   r	  r   r   r   r    ewm_meanr   r4  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   rS  rm   s    rF   	compliantz_ExprNamespace.complianty  s    ###rI   NrX   r   )rY   rZ   r[   r   r   rV  rB   rI   rF   rR  rR  t  s     '&$ $rI   rR  c                      e Zd ZddZy)EagerExprNamespacec                   || _         y rA   rU  rC   exprs     rF   r   zEagerExprNamespace.__init__  
    #rI   N)r\  r   rX   rE  rY   rZ   r[   r   rB   rI   rF   rY  rY  ~      $rI   rY  c                      e Zd ZddZy)LazyExprNamespacec                   || _         y rA   rU  r[  s     rF   r   zLazyExprNamespace.__init__  r]  rI   N)r\  r   rX   rE  r^  rB   rI   rF   ra  ra    r_  rI   ra  c                      e Zd ZddZy)r3  c                :    | j                   j                  dd      S )Nr4  get_categoriesrV  r,  rm   s    rF   re  z$EagerExprCatNamespace.get_categories  s    ~~55e=MNNrI   NrX   r   )rY   rZ   r[   re  rB   rI   rF   r3  r3    s    OrI   r3  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) r7  c                >    | j                   j                  dd|      S )Nr8  	to_stringformatrf  rC   rl  s     rF   rj  z$EagerExprDateTimeNamespace.to_string  s    ~~55dKPV5WWrI   c                >    | j                   j                  dd|      S )Nr8  replace_time_zone	time_zonerf  rC   rq  s     rF   ro  z,EagerExprDateTimeNamespace.replace_time_zone  &    ~~55% 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr8  convert_time_zonerp  rf  rr  s     rF   ru  z,EagerExprDateTimeNamespace.convert_time_zone  rs  rI   c                >    | j                   j                  dd|      S )Nr8  	timestamp)	time_unitrf  )rC   rx  s     rF   rw  z$EagerExprDateTimeNamespace.timestamp  s%    ~~55+ 6 
 	
rI   c                :    | j                   j                  dd      S )Nr8  daterf  rm   s    rF   rz  zEagerExprDateTimeNamespace.date      ~~55dFCCrI   c                :    | j                   j                  dd      S )Nr8  yearrf  rm   s    rF   r}  zEagerExprDateTimeNamespace.year  r{  rI   c                :    | j                   j                  dd      S )Nr8  monthrf  rm   s    rF   r  z EagerExprDateTimeNamespace.month  s    ~~55dGDDrI   c                :    | j                   j                  dd      S )Nr8  dayrf  rm   s    rF   r  zEagerExprDateTimeNamespace.day  s    ~~55dEBBrI   c                :    | j                   j                  dd      S )Nr8  hourrf  rm   s    rF   r  zEagerExprDateTimeNamespace.hour  r{  rI   c                :    | j                   j                  dd      S )Nr8  minuterf  rm   s    rF   r  z!EagerExprDateTimeNamespace.minute      ~~55dHEErI   c                :    | j                   j                  dd      S )Nr8  secondrf  rm   s    rF   r  z!EagerExprDateTimeNamespace.second  r  rI   c                :    | j                   j                  dd      S )Nr8  millisecondrf  rm   s    rF   r  z&EagerExprDateTimeNamespace.millisecond      ~~55dMJJrI   c                :    | j                   j                  dd      S )Nr8  microsecondrf  rm   s    rF   r  z&EagerExprDateTimeNamespace.microsecond  r  rI   c                :    | j                   j                  dd      S )Nr8  
nanosecondrf  rm   s    rF   r  z%EagerExprDateTimeNamespace.nanosecond  s    ~~55dLIIrI   c                :    | j                   j                  dd      S )Nr8  ordinal_dayrf  rm   s    rF   r  z&EagerExprDateTimeNamespace.ordinal_day  r  rI   c                :    | j                   j                  dd      S )Nr8  weekdayrf  rm   s    rF   r  z"EagerExprDateTimeNamespace.weekday  s    ~~55dIFFrI   c                :    | j                   j                  dd      S )Nr8  total_minutesrf  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_minutes      ~~55dOLLrI   c                :    | j                   j                  dd      S )Nr8  total_secondsrf  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_seconds  r  rI   c                :    | j                   j                  dd      S )Nr8  total_millisecondsrf  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_milliseconds      ~~55d<PQQrI   c                :    | j                   j                  dd      S )Nr8  total_microsecondsrf  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_microseconds  r  rI   c                :    | j                   j                  dd      S )Nr8  total_nanosecondsrf  rm   s    rF   r  z,EagerExprDateTimeNamespace.total_nanoseconds  s    ~~55d<OPPrI   c                >    | j                   j                  dd|      S )Nr8  truncate)everyrf  )rC   r  s     rF   r  z#EagerExprDateTimeNamespace.truncate  s    ~~55dJe5TTrI   c                >    | j                   j                  dd|      S )Nr8  	offset_bybyrf  rC   r  s     rF   r  z$EagerExprDateTimeNamespace.offset_by  s    ~~55dKB5OOrI   N)rl  r   rX   r   )rq  
str | NonerX   r   )rq  r   rX   r   )rx  r9   rX   r   rg  )r  r   rX   r   r  r   rX   r   )rY   rZ   r[   rj  ro  ru  rw  rz  r}  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   rI   rF   r7  r7    s    X





DDECDFFKKJKGMMRRQUPrI   r7  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)r:  c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.len      ~~55feDDrI   c                :    | j                   j                  dd      S )Nr   r  rf  rm   s    rF   r  zEagerExprListNamespace.unique      ~~55fhGGrI   c                >    | j                   j                  dd|      S )Nr   contains)itemrf  )rC   r  s     rF   r  zEagerExprListNamespace.contains  s    ~~55fjt5TTrI   c                >    | j                   j                  dd|      S )Nr   get)r  rf  )rC   r  s     rF   r  zEagerExprListNamespace.get  s    ~~55fe55QQrI   c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.min  r  rI   c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.max  r  rI   c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.mean  s    ~~55ffEErI   c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.median  r  rI   c                :    | j                   j                  dd      S )Nr   r   rf  rm   s    rF   r   zEagerExprListNamespace.sum  r  rI   c               @    | j                   j                  dd||      S )Nr   r  r  rf  r  s      rF   r  zEagerExprListNamespace.sort  s'    ~~55Fzj 6 
 	
rI   Nrg  )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   r:  r:    s=    EHUREEFHE
rI   r:  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((rI   c                $    | j                  |      S rA   r  )rC   r   s     rF   mapzCompliantExprNameNamespace.map
  s    ""8,,rI   c                ,    | j                  fd      S )Nc                     |  S rA   rB   )r   prefixs    rF   r   z3CompliantExprNameNamespace.prefix.<locals>.<lambda>  s    6(4&0A rI   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.prefix      ""#ABBrI   c                ,    | j                  fd      S )Nc                    |   S rA   rB   )r   suffixs    rF   r   z3CompliantExprNameNamespace.suffix.<locals>.<lambda>  s    4&0A rI   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.suffix  r  rI   c                @    | j                  t        j                        S rA   )r   r   lowerrm   s    rF   to_lowercasez'CompliantExprNameNamespace.to_lowercase      ""399--rI   c                @    | j                  t        j                        S rA   )r   r   upperrm   s    rF   to_uppercasez'CompliantExprNameNamespace.to_uppercase  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>.fn  s    +784DJ888r  )r   r   rX   r   rB   )r   r   s   ` rF   rb   z.CompliantExprNameNamespace._alias_output_names  s    	9 	rI   c                    y rA   rB   r4  s     rF   r   z)CompliantExprNameNamespace._from_callable   rH   rI   NrW  )r   r   rX   r   )r  r   rX   r   )r  r   rX   r   )r   r   rX   r   )r   rF  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)r=  c                <    | j                   }|j                  |      S rA   )rV  r	  )rC   r   r\  s      rF   r   z%EagerExprNameNamespace._from_callable(  s    ~~,,T22rI   N)r   rF  rX   r   rY   rZ   r[   r   rB   rI   rF   r=  r=  #  s    
3rI   r=  c                      e Zd ZddZy)rO  c                f    | j                   }|r| j                  |      nd }|j                  |      S rA   )rV  rb   r	  )rC   r   r\  r   s       rF   r   z$LazyExprNameNamespace._from_callable2  s0    ~~9=t//54,,\::rI   N)r   rF  rX   r   r  rB   rI   rF   rO  rO  -  s    
;rI   rO  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y)r?  c                :    | j                   j                  dd      S )Nr   	len_charsrf  rm   s    rF   r  z"EagerExprStringNamespace.len_chars;  s    ~~55e[IIrI   c               D    | j                   j                  dd||||      S )Nr   replace)patternrL   r@  r  rf  )rC   rL   r  r@  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   r@  rf  )rC   rL   r  r@  s       rF   r  z$EagerExprStringNamespace.replace_allE  s+     ~~55=' 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   strip_chars)
charactersrf  )rC   r  s     rF   r  z$EagerExprStringNamespace.strip_charsL  s%    ~~55=Z 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   starts_with)r  rf  r  s     rF   r  z$EagerExprStringNamespace.starts_withQ      ~~55e]SY5ZZrI   c                >    | j                   j                  dd|      S )Nr   	ends_with)r  rf  r  s     rF   r  z"EagerExprStringNamespace.ends_withT  s    ~~55e[QW5XXrI   c               @    | j                   j                  dd||      S )Nr   r  )r  r@  rf  )rC   r  r@  s      rF   r  z!EagerExprStringNamespace.containsW  s'    ~~55:w 6 
 	
rI   c                @    | j                   j                  dd||      S )Nr   slice)r  lengthrf  )rC   r  r  s      rF   r  zEagerExprStringNamespace.slice\  s'    ~~5576& 6 
 	
rI   c                >    | j                   j                  dd|      S )Nr   splitr  rf  r  s     rF   r  zEagerExprStringNamespace.splita  s    ~~55eW5LLrI   c                >    | j                   j                  dd|      S )Nr   to_datetimerk  rf  rm  s     rF   r  z$EagerExprStringNamespace.to_datetimed  r  rI   c                >    | j                   j                  dd|      S )Nr   to_daterk  rf  rm  s     rF   r  z EagerExprStringNamespace.to_dateg  s    ~~55eYv5VVrI   c                :    | j                   j                  dd      S )Nr   r  rf  rm   s    rF   r  z%EagerExprStringNamespace.to_lowercasej      ~~55e^LLrI   c                :    | j                   j                  dd      S )Nr   r  rf  rm   s    rF   r  z%EagerExprStringNamespace.to_uppercasem  r  rI   c                >    | j                   j                  dd|      S )Nr   zfill)widthrf  )rC   r  s     rF   r  zEagerExprStringNamespace.zfillp  s    ~~55eWE5RRrI   c                :    | j                   j                  dd      S )Nr   to_titlecaserf  rm   s    rF   r  z%EagerExprStringNamespace.to_titlecases  r  rI   Nrg  )
rL   r   r  r   r@  r   r  r   rX   r   )rL   r   r  r   r@  r   rX   r   )r  r  rX   r   )r  r   rX   r   )r  r   rX   r   )r  r   r@  r   rX   r   )r  r   r  rH  rX   r   r  )rl  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  rB   rI   rF   r?  r?  8  s    J

*-
;?
DG
	


*-
;?
	


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



M[WMMSMrI   r?  c                      e Zd ZddZy)rB  c                \    | j                   j                  dd|      j                  |      S )NrC  fieldr   )rV  r,  r   r~   s     rF   r  zEagerExprStructNamespace.fieldz  s.    ~~55hd5SYY
 	
rI   N)r   r   rX   r   )rY   rZ   r[   r  rB   rI   rF   rB  rB  w  s    
rI   rB  N)Z
__future__r   	functoolsr   r=  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=   rR  rY  ra  r3  r7  r:  r  r=  rO  r?  rB  rB   rI   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t	.o|34_l*+t	.p- +-.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;<Mz"OJ$?AT<M~
z"OJ$?AT
rI   