
    GJj6                    8   d dl mZ d dlmZ d dlmZ d dlmZmZm	Z	m
Z
mZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZm Z  d dl!m"Z"m#Z#m$Z$m%Z% d d	l&m'Z'm(Z( d d
l)m*Z* erPd dl+m,Z,m-Z- d dl.m/Z/m0Z0 d dl1m2Z2m3Z3 d dl4m5Z5 d dlm6Z6m7Z7 d dl8m9Z9 d dl:m;Z; d dl!m<Z<m=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZG g dZH G d de      ZI G d deeeef         ZJ G d deJeef   eeef         ZK G d deKeef   eeef         ZL G d deLeef   eeef         ZM G d d eKee f   eee f         ZN G d! d"e#e   ee         ZO G d# d$eOe   e	e         ZP G d% d&eOe   e	e         ZQ G d' d(ePe   ee   e	e         ZR G d) d*ePe   ee   e	e         ZS G d+ d,ePe   ee   e	e         ZT G d- d.eOe   ee   ee         ZU G d/ d0ePe   eUe   e	e         ZV G d1 d2eQe   eUe   e	e         ZW G d3 d4ePe   ee   e	e         ZX G d5 d6ePe   ee   e	e         ZYy7)8    )annotations)partial)methodcaller)TYPE_CHECKINGAnyGenericLiteralProtocol)CatNamespaceDateTimeNamespaceListNamespaceNameNamespaceStringNamespaceStructNamespace)CompliantColumn)	AliasName
AliasNamesCompliantExprT_coCompliantFrameTCompliantLazyFrameTCompliantSeriesOrNativeExprT_coEagerDataFrameT
EagerExprTEagerSeriesT	LazyExprTNativeExprT)_resolve_sample_size_StoresCompliantnot_implementedqualified_type_name)is_numpy_arrayis_numpy_scalar)MultiOutputExpressionError)CallableSequence)SelfTypeIs)CompliantNamespaceEagerNamespace)CompliantSeries)	EvalNames
EvalSeries)ExprMetadata)	NoDefault)ImplementationVersion_LimitedContext)ClosedIntervalFillNullStrategy	IntoDTypeModeKeepStrategyNonNestedLiteral
RankMethodRollingInterpolationMethodTimeUnit)CompliantExprDepthTrackingExpr	EagerExprLazyExpr
NativeExprc                  H    e Zd ZdZd
dZddZddZddZddZddZ	ddZ
y	)r>   a	  An `Expr`-like object from a package with [Lazy-only support](https://narwhals-dev.github.io/narwhals/extending/#levels-of-support).

    Protocol members are chosen *purely* for matching statically - as they
    are common to all currently supported packages.
    c                     y N )selfargskwdss      b/Users/ahmed/devFolder/claude-voice/.venv/lib/python3.12/site-packages/narwhals/_compliant/expr.pybetweenzNativeExpr.betweenF   s    s    c                    y rA   rB   rC   values     rF   __gt__zNativeExpr.__gt__L       SrH   c                    y rA   rB   rJ   s     rF   __lt__zNativeExpr.__lt__M   rM   rH   c                    y rA   rB   rJ   s     rF   __ge__zNativeExpr.__ge__N   rM   rH   c                    y rA   rB   rJ   s     rF   __le__zNativeExpr.__le__O   rM   rH   c                    y rA   rB   rJ   s     rF   __eq__zNativeExpr.__eq__P   rM   rH   c                    y rA   rB   rJ   s     rF   __ne__zNativeExpr.__ne__Q   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d0dZd,dZd,dZd1dZd,dZd,dZd,dZd,dZd,dZd,dZd2d3dZd2d3dZd,dZd,dZd4d Zd4d!Zd,d"Zd,d#Z d,d$Z!d5d%Z"	 	 	 	 	 	 d6d&Z#	 	 	 	 	 	 	 	 d7d'Z$	 	 	 	 	 	 	 	 	 	 d8d(Z%ed9d)       Z&y):r:   r/   _implementationEvalNames[CompliantFrameT]_evaluate_output_namesAliasNames | None_alias_output_namesNzExprMetadata | None_opt_metadatac                L    | j                   d}t        |      | j                   S )Na3  `_opt_metadata` is None. This is usually the result of trying to do some operation (such as `over`) which requires access to the metadata at the compliant level. You may want to consider rewriting your logic so that this operation is not necessary. Ideally you should avoid setting `_opt_metadata` manually.)rc   AssertionError)rC   msgs     rF   	_metadatazCompliantExpr._metadata_   s1    %4  !%%!!!rH   c                     y rA   rB   rC   dfs     rF   __call__zCompliantExpr.__call__l   s    47rH   c                    | S rA   rB   rC   s    rF   __narwhals_expr__zCompliantExpr.__narwhals_expr__o   s    rH   c                     y rA   rB   rm   s    rF   __narwhals_namespace__z$CompliantExpr.__narwhals_namespace__r   s    SVrH   c                    y rA   rB   )clscontextcolumn_indicess      rF   from_column_indicesz!CompliantExpr.from_column_indicess   s     rH   c                   y rA   rB   rr   evaluate_column_namesrs   s      rF   from_column_nameszCompliantExpr.from_column_namesw        rH   c                     y rA   rB   rm   s    rF   	broadcastzCompliantExpr.broadcast   s    rH   c                h    | j                         }| |j                  dd       j                         z   S )Ng        )rp   litr|   )rC   plxs     rF   _is_close_float_promotez%CompliantExpr._is_close_float_promote   s1     ))+cggc4(22444rH   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   r   rB   rH   rF   r:   r:   T   s    $#66** *.M&-
" 
"8!8	28 W!,;	  9
 ! 
  %5 ,; !>=#,,#%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<   	 	 	 	 	 	 	 	 	 	 	 	 dudZdvdZ	 	 dwdZe	 	 	 	 	 	 	 	 	 	 dxd       Zedyd       Z	dzdZ
d	d
	 	 	 	 	 	 	 d{dZd	d
	 	 	 d|dZed}d       Z	 	 	 	 	 	 	 	 	 	 d~dZ	 	 	 	 	 	 	 	 ddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZddZdd Z dd!Z!dd"Z"dd#Z#dd$Z$dd%Z%dd&Z&dd'Z'dd(Z(dd)Z)dd*Z*dd+Z+dd,Z,dd-Z-dd.Z.dd/Z/dd0Z0dd1Z1dd2Z2dd3Z3dd4Z4dd5Z5dd6Z6dd7Z7dd8Z8dd9Z9dd:Z:dd;Z;dd<Z<dd=Z=dd>Z>dd?Z?	 	 	 	 	 	 	 	 dd@Z@ddAZAddBZBddCZCddDZD	 	 	 	 	 	 	 	 	 	 ddEZEddFZFddGZGddHZHddIZI	 	 	 	 	 	 	 	 	 	 ddJZJddKZKddLZLddMZMddNZN	 	 	 	 	 	 ddOZOddPZPddQZQddRZRddSZSddTZTddUZUddVZVddWZWddXZXddYZY	 	 	 	 	 	 	 	 	 	 ddZZZdd[Z[	 	 	 	 	 	 	 	 	 	 dd\Z\	 	 	 	 	 	 	 	 dd]Z]dd^Z^dd_Z_dd`Z`ddaZaddbZbddcZcdddZdddeZeddfZfddgZgddhZhddiZi	 	 	 	 	 	 	 	 ddjZjdddkZkdddlZlddmZmenddn       Zoenddo       Zpenddp       Zqenddq       Zrenddr       Zsendds       Ztyt)r<   )EvalSeries[EagerDataFrameT, EagerSeriesT]_callc                    y rA   rB   )rC   callevaluate_output_namesalias_output_namesimplementationversions         rF   __init__zEagerExpr.__init__   s     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                @   rKt         |        j                  |             d      D cg c]  \  }}|j                  |       c}}S t         |       j                  |       d      D cg c]  \  }}|j                  |       c}}S c c}}w c c}}w )NTstrict)zipr`   r   )rj   r  r   r   rC   s      rF   r   z0EagerExpr._with_alias_output_names.<locals>.func*  s    ! ),R*4+F+Fr+JK#)) LL&)  %(Hd99"=d%%LFD T"% s   B5Br   rj   r   rX   zlist[EagerSeriesT])rb   	__class__r`   r^   r   )rC   r  r   r   r  s   `` @@rF   _with_alias_output_namesz"EagerExpr._with_alias_output_names  sp    %)%=%=" !  *5	
 M 		" ~~"&"="=1//MM  
 	
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_seriesC  s^     $$
#)
 	
 """&"="=#77	 # 
 	
rH   c                   i S rA   rB   )rC   r   s     rF   _reuse_series_extra_kwargsz$EagerExpr._reuse_series_extra_kwargs`  s	     	rH   c                    t        |d      S )Nrn   )hasattr)rr   objs     rF   _is_exprzEagerExpr._is_expre  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      D              rd|
 d}t        |      |	S c c}}w c c}w )Nr  c              3  4   K   | ]  }|j                     y wrA   r  ).0ss     rF   	<genexpr>z0EagerExpr._reuse_series_inner.<locals>.<genexpr>  s     5Jcaffc   c              3  ,   K   | ]  \  }}||k7    y wrA   rB   )r'  r   r   s      rF   r)  z0EagerExpr._reuse_series_inner.<locals>.<genexpr>  s      
-MkeTETM-Ms   Tr  ztSafety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues
Expression aliases: 
)
itemsr$  _evaluate_single_output_exprr   r   _from_scalarr   r   r  re   )rC   rj   r  r   r  r   rK   methodr  outaliasesr   rf   s                rF   r  zEagerExpr._reuse_series_inneri  s2     &||~	
  .e }}U# 11%8  .	 	 
 
--^-L
 
 r('
" 4BFv/vf~U" 	 '
 //35Jc5J 
-0%-M
 
''.ir3  !%%
1
'
s   /C#.(C)c                n     d fd} j                  | j                   j                         S )a  Reuse Series implementation for expression.

        Just like `_reuse_series`, but for e.g. `Expr.dt.foo` instead
        of `Expr.foo`.

        Arguments:
            series_namespace: The Series namespace.
            method_name: name of method, within `series_namespace`.
            expressifiable_args: keyword arguments to pass to function, which may
                be expressifiable (e.g. `nw.col('a').str.replace('abc', nw.col('b')))`).
        c           
        j                         D ci c]*  \  }}|j                  |      r| j                  |      n|, }}} |       D cg c]  } t        t        |            di |  c}S c c}}w c c}w )NrB   )r-  r$  r.  getattr)	rj   r   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   r7  r  r6  r8  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   rE  s     rF   rD  zEagerExpr.cast  s    !!&!66rH   c               (    | j                  ||      S )NotherrF  rC   operatorrI  s      rF   _with_binaryzEagerExpr._with_binary  s    !!(%!88rH   c               F    | j                  d      j                  ||      S )NliteralrH  )r   r  rJ  s      rF   _with_binary_rightzEagerExpr._with_binary_right  s!    zz)$22852IIrH   c                &    | j                  d|      S )NrU   rL  rC   rI  s     rF   rU   zEagerExpr.__eq__        511rH   c                &    | j                  d|      S )NrW   rQ  rR  s     rF   rW   zEagerExpr.__ne__  rS  rH   c                &    | j                  d|      S )NrQ   rQ  rR  s     rF   rQ   zEagerExpr.__ge__  rS  rH   c                &    | j                  d|      S )NrL   rQ  rR  s     rF   rL   zEagerExpr.__gt__  rS  rH   c                &    | j                  d|      S )NrS   rQ  rR  s     rF   rS   zEagerExpr.__le__  rS  rH   c                &    | j                  d|      S )NrO   rQ  rR  s     rF   rO   zEagerExpr.__lt__  rS  rH   c                &    | j                  d|      S )N__and__rQ  rR  s     rF   rZ  zEagerExpr.__and__        E22rH   c                &    | j                  d|      S )N__or__rQ  rR  s     rF   r]  zEagerExpr.__or__  rS  rH   c                &    | j                  d|      S )N__add__rQ  rR  s     rF   r_  zEagerExpr.__add__  r[  rH   c                &    | j                  d|      S )N__sub__rQ  rR  s     rF   ra  zEagerExpr.__sub__  r[  rH   c                &    | j                  d|      S )N__rsub__rO  rR  s     rF   rc  zEagerExpr.__rsub__      &&z599rH   c                &    | j                  d|      S )N__mul__rQ  rR  s     rF   rg  zEagerExpr.__mul__  r[  rH   c                &    | j                  d|      S )N__truediv__rQ  rR  s     rF   ri  zEagerExpr.__truediv__  s      66rH   c                &    | j                  d|      S )N__rtruediv__rd  rR  s     rF   rk  zEagerExpr.__rtruediv__  s    &&~u==rH   c                &    | j                  d|      S )N__floordiv__rQ  rR  s     rF   rm  zEagerExpr.__floordiv__  s      77rH   c                &    | j                  d|      S )N__rfloordiv__rd  rR  s     rF   ro  zEagerExpr.__rfloordiv__  s    &&>>rH   c                &    | j                  d|      S )N__pow__rQ  rR  s     rF   rq  zEagerExpr.__pow__  r[  rH   c                &    | j                  d|      S )N__rpow__rd  rR  s     rF   rs  zEagerExpr.__rpow__  re  rH   c                &    | j                  d|      S )N__mod__rQ  rR  s     rF   ru  zEagerExpr.__mod__  r[  rH   c                &    | j                  d|      S )N__rmod__rd  rR  s     rF   rw  zEagerExpr.__rmod__  re  rH   c                $    | j                  d      S )N
__invert__rF  rm   s    rF   ry  zEagerExpr.__invert__	      !!,//rH   c                $    | j                  d      S )N__neg__rF  rm   s    rF   r|  zEagerExpr.__neg__      !!),,rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.null_count  s    !!,t!DDrH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.n_unique      !!*T!BBrH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.sum      !!%!==rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.count  s    !!'$!??rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.mean      !!&!>>rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.median  s    !!(4!@@rH   c               *    | j                  dd|      S )Nr   Tr   r   rF  r   s     rF   r   zEagerExpr.std"      !!%4!HHrH   c               *    | j                  dd|      S )Nr   Tr  rF  r   s     rF   r   zEagerExpr.var%  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.skew(  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.kurtosis+  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.any.  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.all1  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.max4  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.min7  r  rH   c                (    | j                  dd      S )Narg_minTr  rF  rm   s    rF   r  zEagerExpr.arg_min:      !!)D!AArH   c                (    | j                  dd      S )Narg_maxTr  rF  rm   s    rF   r  zEagerExpr.arg_max=  r  rH   c                *    | j                  d||      S )Nclip)lower_boundupper_boundrF  )rC   r  r  s      rF   r  zEagerExpr.clipB  s!    !! " 
 	
rH   c                (    | j                  d|      S )N
clip_lower)r  rF  )rC   r  s     rF   r  zEagerExpr.clip_lowerG      !!,K!HHrH   c                (    | j                  d|      S )N
clip_upper)r  rF  )rC   r  s     rF   r  zEagerExpr.clip_upperJ  r  rH   c                $    | j                  d      S )Nis_nullrF  rm   s    rF   r  zEagerExpr.is_nullM  r}  rH   c                $    | j                  d      S )Nis_nanrF  rm   s    rF   r  zEagerExpr.is_nanP  s    !!(++rH   c                (    | j                  d|      S )Nfill_nan)rK   rF  rJ   s     rF   r  zEagerExpr.fill_nanS  s    !!*E!::rH   c                ,    | j                  d|||      S )N	fill_null)rK   strategylimitrF  )rC   rK   r  r  s       rF   r  zEagerExpr.fill_nullV  s%     !!uxu " 
 	
rH   c                (    | j                  d|      S )Nis_inrH  rF  rR  s     rF   r  zEagerExpr.is_in]  s    !!'!77rH   c                $    | j                  d      S )Narg_truerF  rm   s    rF   r  zEagerExpr.arg_true`  s    !!*--rH   c                l    | j                         } |j                  |ddi}| j                  d|      S )Nr   Ffilter)	predicate)rp   all_horizontalr  )rC   
predicatesr   r  s       rF   r  zEagerExpr.filterc  s=    ))+&C&&
GG	!!(i!@@rH   c                $    | j                  d      S )N
drop_nullsrF  rm   s    rF   r  zEagerExpr.drop_nullsh  rz  rH   c               .    | j                  d||||      S )Nr   )r   r   r   r   rF  r   s        rF   r   zEagerExpr.replace_strictk  s'     !!#3l " 
 	
rH   c               *    | j                  d||      S )Nsort
descending
nulls_lastrF  rC   r  r  s      rF   r  zEagerExpr.sortw  s    !!&ZJ!WWrH   c                $    | j                  d      S )NabsrF  rm   s    rF   r  zEagerExpr.absz      !!%((rH   c                (    | j                  dd      S )NuniqueF)maintain_orderrF  rm   s    rF   r  zEagerExpr.unique}  s    !!(5!AArH   c                $    | j                  d      S )NdiffrF  rm   s    rF   r  zEagerExpr.diff      !!&))rH   c                    t        t        ||      d fd} j                  | j                   j                         S )N)nfractionwith_replacementc           	          |       D cg c]+  }|j                   |j                                     - c}S c c}w )N)height)r  r  seed)sampler   )rj   r   _resolve_sample_size_from_heightr  rC   r  s     rF   r   zEagerExpr.sample.<locals>.func  sT     #2h 'F 6fjjlK%5  
 '  s   0?r  rj   r   rX   Sequence[EagerSeriesT])r   r   r   r`   rb   )rC   r  r  r  r  r   r  s   `  `` @rF   r  zEagerExpr.sample  sX     ,3 -	,
(	 	 """&"="=#77	 # 
 	
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   )rA  r`   r^   r   )rC   r   r   s   `` rF   r   zEagerExpr.alias  s<    	 tDzB"&"="=1//MM
 	
rH   c                $    | j                  d      S )N	is_uniquerF  rm   s    rF   r  zEagerExpr.is_unique      !!+..rH   c                $    | j                  d      S )Nis_first_distinctrF  rm   s    rF   r  zEagerExpr.is_first_distinct  s    !!"566rH   c                $    | j                  d      S )Nis_last_distinctrF  rm   s    rF   r  zEagerExpr.is_last_distinct  s    !!"455rH   c                ,    | j                  dd||      S )Nr   T)r   r   r   rF  r   s      rF   r   zEagerExpr.quantile  s(     !!'	 " 
 	
rH   c                (    | j                  d|      S )Nheadr  rF  rC   r  s     rF   r  zEagerExpr.head      !!&A!..rH   c                (    | j                  d|      S )Ntailr  rF  r  s     rF   r  zEagerExpr.tail  r  rH   c                (    | j                  d|      S )Nround)decimalsrF  )rC   r  s     rF   r  zEagerExpr.round  s    !!'H!==rH   c                $    | j                  d      S )NfloorrF  rm   s    rF   r  zEagerExpr.floor  s    !!'**rH   c                $    | j                  d      S )NceilrF  rm   s    rF   r  zEagerExpr.ceil  r  rH   c                (    | j                  dd      S )Nr   Tr  rF  rm   s    rF   r   zEagerExpr.len  r  rH   c                *    | j                  d||      S )Ngather_every)r  offsetrF  )rC   r  r  s      rF   r  zEagerExpr.gather_every  s    !!.Af!EErH   c               (    | j                  d|      S )Nmode)keeprF  )rC   r  s     rF   r  zEagerExpr.mode  s    !!&t!44rH   c                $    | j                  d      S )N	is_finiterF  rm   s    rF   r  zEagerExpr.is_finite  r  rH   c               ,    | j                  d|||      S )Nrolling_meanwindow_sizemin_samplescenterrF  rC   r  r  r  s       rF   r  zEagerExpr.rolling_mean  s&    !!##	 " 
 	
rH   c               .    | j                  d||||      S )Nrolling_stdr  r  r  r   rF  rC   r  r  r  r   s        rF   r  zEagerExpr.rolling_std  +     !!## " 
 	
rH   c               ,    | j                  d|||      S )Nrolling_sumr  rF  r  s       rF   r  zEagerExpr.rolling_sum  s$    !!{TZ " 
 	
rH   c               .    | j                  d||||      S )Nrolling_varr  rF  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        ||d      }t        |      st        |      r,t	        |j
                        t        fd|D              }nIt        ||j                        rt        d |D              }n |j                  t        fd	|D              }t        fd
|D              }t        d |D              }sRt        |      rGt        |       dkD  r9|j                  d      }	t        ||	         }
dt        |
       d}t        |      |S )Nc              3  4   K   | ]  }|j                     y wrA   r  )r'  input_seriess     rF   r)  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s     P-,L---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   Tr  )rs   c              3  R   K   | ]  \  }} |      j                  |         y wrA   r  )r'  arrout_name
from_numpys      rF   r)  z6EagerExpr.map_batches.<locals>.func.<locals>.<genexpr>  s'     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   )rD  )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  zG`map_batches` with `returns_scalar=False` must return a Series; found 'zQ'.

If `returns_scalar` is set to `True`, a returned value can be a scalar value.)tupler  r!   r"   r   r  
isinstancer  r/  r   r   indexrA  r    	TypeError)rj   udf_series_inr  udf_series_out	_first_in
_first_outitr@  is_scalar_result_idx_typerf   r  r  r   r   r   rC   s               @@rF   r   z#EagerExpr.map_batches.<locals>.func  sD    HMP-PL""P-"PPN$1!$4nQ6GzI ^\$?Bj)_Z-H$Y%9%94H
WTVWWJ	(;(;<QbQQ'44XUWXX'NvNN$$A&$AA",<(=3r7Q;'--d3^D121%89 :PP 
  n$MrH   r  r  r9  )rC   r   r   r   r   s   ```` rF   r   zEagerExpr.map_batches  s@    	 	@ """&"="=#77	 # 
 	
rH   c                (    | j                  d|      S )Nshiftr  rF  r  s     rF   r$  zEagerExpr.shift3  s    !!'Q!//rH   c               (    | j                  d|      S )Ncum_sumreverserF  rC   r(  s     rF   r&  zEagerExpr.cum_sum6      !!)W!==rH   c               (    | j                  d|      S )N	cum_countr'  rF  r)  s     rF   r,  zEagerExpr.cum_count9  s    !!+w!??rH   c               (    | j                  d|      S )Ncum_minr'  rF  r)  s     rF   r.  zEagerExpr.cum_min<  r*  rH   c               (    | j                  d|      S )Ncum_maxr'  rF  r)  s     rF   r0  zEagerExpr.cum_max?  r*  rH   c               (    | j                  d|      S )Ncum_prodr'  rF  r)  s     rF   r2  zEagerExpr.cum_prodB  s    !!*g!>>rH   c               *    | j                  d||      S )Nrank)r0  r  rF  )rC   r0  r  s      rF   r4  zEagerExpr.rankE  s    !!&J!OOrH   c                (    | j                  d|      S )Nlog)baserF  )rC   r7  s     rF   r6  zEagerExpr.logH  s    !!%d!33rH   c                $    | j                  d      S )NexprF  rm   s    rF   r9  zEagerExpr.expK  r  rH   c                $    | j                  d      S )NsinrF  rm   s    rF   r;  zEagerExpr.sinN  r  rH   c                $    | j                  d      S )NcosrF  rm   s    rF   r=  zEagerExpr.cosQ  r  rH   c                $    | j                  d      S )NsqrtrF  rm   s    rF   r?  zEagerExpr.sqrtT  r  rH   c                ,    | j                  d|||      S )N
is_between)r  r  closedrF  )rC   r  r  rB  s       rF   rA  zEagerExpr.is_betweenW  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>.funcb  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 rE  )r  r   rF  s    rF   r   zEagerExpr.last.<locals>.funcq  s)    (uGB499;r?"rH   r  rG  rH  rI  s   `` rF   r   zEagerExpr.lastm  sS    %%fT%BB	# """&"="=#77	 # 
 	
rH   c               *    | j                  dd|      S )Nr   T)r   r   rF  r   s     rF   r   zEagerExpr.any_value|  s!    !!< " 
 	
rH   c                    t        |       S rA   )EagerExprCatNamespacerm   s    rF   catzEagerExpr.cat      $T**rH   c                    t        |       S rA   )EagerExprDateTimeNamespacerm   s    rF   dtzEagerExpr.dt  s    )$//rH   c                    t        |       S rA   )EagerExprListNamespacerm   s    rF   r   zEagerExpr.list      %d++rH   c                    t        |       S rA   )EagerExprNameNamespacerm   s    rF   r   zEagerExpr.name  rV  rH   c                    t        |       S rA   )EagerExprStringNamespacerm   s    rF   r   zEagerExpr.str      '--rH   c                    t        |       S rA   )EagerExprStructNamespacerm   s    rF   structzEagerExpr.struct  r[  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   r_  r   ra   rs   r1   rX   r&   )r  r   rX   r&   )r  AliasName | NonerX   r&   )r  r   r   r   r  r   rX   r&   )r   r   rX   zdict[str, Any])r#  z
Self | AnyrX   zTypeIs[Self])
rj   r   r  r   r   r   r  r   rX   r  )r7  z5Literal['cat', 'dt', 'list', 'name', 'str', 'struct']r  r   r6  r   rX   r&   r   )rE  r4   rX   r&   )rK  r   rI  r&   rX   r&   )rI  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&   )rI  r   rX   r&   )r  r&   rX   r&   r   )r  r   r  r   rX   r&   )
r  rc  r  rb  r  r   r  rc  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&   )r0  r7   r  r   rX   r&   )r7  r   rX   r&   )r  r&   r  r&   rB  r2   rX   r&   r   r   r   )rX   zEagerExprCatNamespace[Self])rX   z EagerExprDateTimeNamespace[Self])rX   zEagerExprListNamespace[Self])rX   zEagerExprNameNamespace[Self])rX   zEagerExprStringNamespace[Self])rX   zEagerExprStructNamespace[Self])urY   rZ   r[   r   r   rk   rp   r   r   r  r  r  r   r$  r  r:  r|   rD  rL  rO  rU   rW   rQ   rL   rS   rO   rZ  r]  r_  ra  rc  rg  ri  rk  rm  ro  rq  rs  ru  rw  ry  r|  r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  r   r  r  r  r   r  r  r  r  r  r   r  r  r  r  r  r  r  r   r$  r&  r,  r.  r0  r2  r4  r6  r9  r;  r=  r?  rA  r   r   r   r   rO  rS  r   r   r   r^  rB   rH   rF   r<   r<      s    547  :	
 . '  
L	FL 
7
  :	

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

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

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

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

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

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

 + + 0 0 , , , , . . . .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   rB  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  rP  rH   r   rO  N)r   ra   rX   r&   r   )rX   zLazyExprNameNamespace[Self])rY   rZ   r[   r  r   r   r   r   ewm_meanr   rO  r   rB   rH   rF   r=   r=     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   rn  rm   s    rF   	compliantz_ExprNamespace.compliant  s    ###rH   NrX   r   )rY   rZ   r[   r   r   rq  rB   rH   rF   rm  rm    s     '&$ $rH   rm  c                      e Zd ZddZy)EagerExprNamespacec                   || _         y rA   rp  rC   exprs     rF   r   zEagerExprNamespace.__init__  
    #rH   N)rw  r   rX   r`  rY   rZ   r[   r   rB   rH   rF   rt  rt        $rH   rt  c                      e Zd ZddZy)LazyExprNamespacec                   || _         y rA   rp  rv  s     rF   r   zLazyExprNamespace.__init__  rx  rH   N)rw  r   rX   r`  ry  rB   rH   rF   r|  r|    rz  rH   r|  c                      e Zd ZddZy)rN  c                :    | j                   j                  dd      S )NrO  get_categoriesrq  r:  rm   s    rF   r  z$EagerExprCatNamespace.get_categories  s    ~~55e=MNNrH   NrX   r   )rY   rZ   r[   r  rB   rH   rF   rN  rN    s    OrH   rN  c                      e Zd ZddZddZddZddZddZddZddZ	ddZ
dd	Zdd
Z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) rR  c                >    | j                   j                  dd|      S )NrS  	to_stringformatr  rC   r  s     rF   r  z$EagerExprDateTimeNamespace.to_string  s    ~~55dKPV5WWrH   c                >    | j                   j                  dd|      S )NrS  replace_time_zone	time_zoner  rC   r  s     rF   r  z,EagerExprDateTimeNamespace.replace_time_zone  &    ~~55% 6 
 	
rH   c                >    | j                   j                  dd|      S )NrS  convert_time_zoner  r  r  s     rF   r  z,EagerExprDateTimeNamespace.convert_time_zone  r  rH   c                >    | j                   j                  dd|      S )NrS  	timestamp)	time_unitr  )rC   r  s     rF   r  z$EagerExprDateTimeNamespace.timestamp  s%    ~~55+ 6 
 	
rH   c                :    | j                   j                  dd      S )NrS  dater  rm   s    rF   r  zEagerExprDateTimeNamespace.date      ~~55dFCCrH   c                :    | j                   j                  dd      S )NrS  yearr  rm   s    rF   r  zEagerExprDateTimeNamespace.year  r  rH   c                :    | j                   j                  dd      S )NrS  monthr  rm   s    rF   r  z EagerExprDateTimeNamespace.month  s    ~~55dGDDrH   c                :    | j                   j                  dd      S )NrS  dayr  rm   s    rF   r  zEagerExprDateTimeNamespace.day  s    ~~55dEBBrH   c                :    | j                   j                  dd      S )NrS  hourr  rm   s    rF   r  zEagerExprDateTimeNamespace.hour  r  rH   c                :    | j                   j                  dd      S )NrS  minuter  rm   s    rF   r  z!EagerExprDateTimeNamespace.minute      ~~55dHEErH   c                :    | j                   j                  dd      S )NrS  secondr  rm   s    rF   r  z!EagerExprDateTimeNamespace.second  r  rH   c                :    | j                   j                  dd      S )NrS  millisecondr  rm   s    rF   r  z&EagerExprDateTimeNamespace.millisecond      ~~55dMJJrH   c                :    | j                   j                  dd      S )NrS  microsecondr  rm   s    rF   r  z&EagerExprDateTimeNamespace.microsecond  r  rH   c                :    | j                   j                  dd      S )NrS  
nanosecondr  rm   s    rF   r  z%EagerExprDateTimeNamespace.nanosecond  s    ~~55dLIIrH   c                :    | j                   j                  dd      S )NrS  ordinal_dayr  rm   s    rF   r  z&EagerExprDateTimeNamespace.ordinal_day  r  rH   c                :    | j                   j                  dd      S )NrS  weekdayr  rm   s    rF   r  z"EagerExprDateTimeNamespace.weekday  s    ~~55dIFFrH   c                :    | j                   j                  dd      S )NrS  total_minutesr  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_minutes      ~~55dOLLrH   c                :    | j                   j                  dd      S )NrS  total_secondsr  rm   s    rF   r  z(EagerExprDateTimeNamespace.total_seconds  r  rH   c                :    | j                   j                  dd      S )NrS  total_millisecondsr  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_milliseconds      ~~55d<PQQrH   c                :    | j                   j                  dd      S )NrS  total_microsecondsr  rm   s    rF   r  z-EagerExprDateTimeNamespace.total_microseconds  r  rH   c                :    | j                   j                  dd      S )NrS  total_nanosecondsr  rm   s    rF   r  z,EagerExprDateTimeNamespace.total_nanoseconds  s    ~~55d<OPPrH   c                >    | j                   j                  dd|      S )NrS  truncate)everyr  )rC   r  s     rF   r  z#EagerExprDateTimeNamespace.truncate  s    ~~55dJe5TTrH   c                >    | j                   j                  dd|      S )NrS  	offset_bybyr  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   r  )r  r   rX   r   r  r   rX   r   )rY   rZ   r[   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rB   rH   rF   rR  rR    s    X





DDECDFFKKJKGMMRRQUPrH   rR  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)rU  c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.len      ~~55feDDrH   c                :    | j                   j                  dd      S )Nr   r  r  rm   s    rF   r  zEagerExprListNamespace.unique!      ~~55fhGGrH   c                >    | j                   j                  dd|      S )Nr   contains)itemr  )rC   r  s     rF   r  zEagerExprListNamespace.contains$  s    ~~55fjt5TTrH   c                >    | j                   j                  dd|      S )Nr   get)r  r  )rC   r  s     rF   r  zEagerExprListNamespace.get'  s    ~~55fe55QQrH   c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.min*  r  rH   c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.max-  r  rH   c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.mean0  s    ~~55ffEErH   c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.median3  r  rH   c                :    | j                   j                  dd      S )Nr   r   r  rm   s    rF   r   zEagerExprListNamespace.sum6  r  rH   c               @    | j                   j                  dd||      S )Nr   r  r  r  r  s      rF   r  zEagerExprListNamespace.sort9  s'    ~~55Fzj 6 
 	
rH   Nr  )r  r6   rX   r   )r  r   rX   r   )r  r   r  r   rX   r   )rY   rZ   r[   r   r  r  r  r   r   r   r   r   r  rB   rH   rF   rU  rU    s=    EHUREEFHE
rH   rU  c                  V    e Zd Zd
dZddZddZddZd
dZd
dZe	dd       Z
ddZy	)CompliantExprNameNamespacec                $    | j                  d       S rA   r   rm   s    rF   r  zCompliantExprNameNamespace.keepD  s    ""4((rH   c                $    | j                  |      S rA   r  )rC   r   s     rF   mapzCompliantExprNameNamespace.mapG  s    ""8,,rH   c                ,    | j                  fd      S )Nc                     |  S rA   rB   )r   prefixs    rF   r  z3CompliantExprNameNamespace.prefix.<locals>.<lambda>K  s    6(4&0ArH   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.prefixJ      ""#ABBrH   c                ,    | j                  fd      S )Nc                    |   S rA   rB   )r   suffixs    rF   r  z3CompliantExprNameNamespace.suffix.<locals>.<lambda>N  s    4&0ArH   r  rC   r  s    `rF   r  z!CompliantExprNameNamespace.suffixM  r  rH   c                @    | j                  t        j                        S rA   )r   r   lowerrm   s    rF   to_lowercasez'CompliantExprNameNamespace.to_lowercaseP      ""399--rH   c                @    | j                  t        j                        S rA   )r   r   upperrm   s    rF   to_uppercasez'CompliantExprNameNamespace.to_uppercaseS  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>.fnX  s    +78<4DJ<888r  )r  r   rX   r   rB   )r   r   s   ` rF   rb   z.CompliantExprNameNamespace._alias_output_namesV  s    	9 	rH   c                    y rA   rB   rB  s     rF   r   z)CompliantExprNameNamespace._from_callable]  s    crH   Nrr  )r   r   rX   r   )r  r   rX   r   )r  r   rX   r   )r   r   rX   r   )r   ra  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)rX  c                <    | j                   }|j                  |      S rA   )rq  r  )rC   r   rw  s      rF   r   z%EagerExprNameNamespace._from_callablee  s    ~~,,T22rH   N)r   ra  rX   r   rY   rZ   r[   r   rB   rH   rF   rX  rX  `  s    
3rH   rX  c                      e Zd ZddZy)rj  c                f    | j                   }|r| j                  |      nd }|j                  |      S rA   )rq  rb   r  )rC   r   rw  r  s       rF   r   z$LazyExprNameNamespace._from_callableo  s0    ~~9=t//54,,\::rH   N)r   ra  rX   r   r  rB   rH   rF   rj  rj  j  s    
;rH   rj  c                      e Zd ZddZ	 	 	 	 	 	 	 	 	 	 ddZ	 	 	 	 	 	 	 	 ddZddZddZddZddZ	ddZ
dd	Zdd
ZddZddZddZddZddZddZdd dZdd dZy)!rZ  c                :    | j                   j                  dd      S )Nr   	len_charsr  rm   s    rF   r  z"EagerExprStringNamespace.len_charsx  s    ~~55e[IIrH   c               D    | j                   j                  dd||||      S )Nr   replace)patternrK   rN  r  r  )rC   rK   r  rN  r  s        rF   r  z EagerExprStringNamespace.replace{  s-     ~~559gUGq 6 
 	
rH   c               B    | j                   j                  dd|||      S )Nr   replace_all)r  rK   rN  r  )rC   rK   r  rN  s       rF   r  z$EagerExprStringNamespace.replace_all  s+     ~~55=' 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   strip_chars)
charactersr  )rC   r  s     rF   r  z$EagerExprStringNamespace.strip_chars  s%    ~~55=Z 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   starts_with)r  r  r  s     rF   r  z$EagerExprStringNamespace.starts_with      ~~55e]SY5ZZrH   c                >    | j                   j                  dd|      S )Nr   	ends_with)r  r  r  s     rF   r  z"EagerExprStringNamespace.ends_with  s    ~~55e[QW5XXrH   c               @    | j                   j                  dd||      S )Nr   r  )r  rN  r  )rC   r  rN  s      rF   r  z!EagerExprStringNamespace.contains  s'    ~~55:w 6 
 	
rH   c                @    | j                   j                  dd||      S )Nr   slice)r  lengthr  )rC   r  r  s      rF   r  zEagerExprStringNamespace.slice  s'    ~~5576& 6 
 	
rH   c                >    | j                   j                  dd|      S )Nr   splitr  r  r  s     rF   r  zEagerExprStringNamespace.split  s    ~~55eW5LLrH   c                >    | j                   j                  dd|      S )Nr   to_datetimer  r  r  s     rF   r
  z$EagerExprStringNamespace.to_datetime  r   rH   c                >    | j                   j                  dd|      S )Nr   to_dater  r  r  s     rF   r  z EagerExprStringNamespace.to_date      ~~55eYv5VVrH   c                >    | j                   j                  dd|      S )Nr   to_timer  r  r  s     rF   r  z EagerExprStringNamespace.to_time  r  rH   c                :    | j                   j                  dd      S )Nr   r  r  rm   s    rF   r  z%EagerExprStringNamespace.to_lowercase      ~~55e^LLrH   c                :    | j                   j                  dd      S )Nr   r  r  rm   s    rF   r  z%EagerExprStringNamespace.to_uppercase  r  rH   c                >    | j                   j                  dd|      S )Nr   zfill)widthr  )rC   r  s     rF   r  zEagerExprStringNamespace.zfill  s    ~~55eWE5RRrH   c                :    | j                   j                  dd      S )Nr   to_titlecaser  rm   s    rF   r  z%EagerExprStringNamespace.to_titlecase  r  rH   c                @    | j                   j                  dd||      S )Nr   	pad_startr  	fill_charr  rC   r  r  s      rF   r  z"EagerExprStringNamespace.pad_start  s'    ~~55;v 6 
 	
rH   c                @    | j                   j                  dd||      S )Nr   pad_endr  r  r  s      rF   r  z EagerExprStringNamespace.pad_end  s'    ~~559Vy 6 
 	
rH   Nr  )
rK   r   r  r   rN  r   r  r   rX   r   )rK   r   r  r   rN  r   rX   r   )r  r  rX   r   )r  r   rX   r   )r  r   rX   r   )r  r   rN  r   rX   r   )r  r   r  rc  rX   r   r  )r  r  rX   r   )r  r   rX   r   ) )r  r   r  r   rX   r   )rY   rZ   r[   r  r  r  r  r  r  r  r  r  r
  r  r  r  r  r  r  r  r  rB   rH   rF   rZ  rZ  u  s    J

*-
;?
DG
	


*-
;?
	


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



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

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