
    Mh                      S SK Jr  S SKrS SKJr  S SKrS SKJr  S SKrS SKJ	r	J
r
JrJrJr  S SKrS SKrS SKJr  S SKJr  S SKJr  S S	KJrJrJrJrJrJrJrJr  S S
K J!r!  S SK"J#r#  S SK$J%r%  S SK&J'r'  S SK(J)r)  S SK*J+r+J,r,J-r-J.r.J/r/  S SK0J1r1J2r2  S SK3J4r4J5r5J6r6  S SK7J8r8  S SK9J:s  J;r<  S SK=J>r>  \	(       a*  S SK?J@r@JArAJBrBJCrCJDrD  S SKEJFrFJGrGJHrH  S SKIJJrJ  S SKKJLrL  S SKMJNrN  \O\P\
4   rQ        S6                 S7S jjrR " S S\R                  S9rT " S S\T5      rU " S  S\U5      rV " S! S"\V5      rW " S# S$\V5      rX " S% S&\U5      rY " S' S(\T5      rZ " S) S*\Z5      r[    S8S+ jr\S9S, jr]    S:S- jr^    S;S. jr_          S<S/ jr`S=S0 jraS>S1 jrbS?S2 jrc    S@S3 jrdSAS4 jre        SBS5 jrfg)C    )annotationsN)defaultdict)partial)TYPE_CHECKINGAnyCallableLiteralcast)option_context)lib)BlockValuesRefs)AggFuncTypeAggFuncTypeBaseAggFuncTypeDict
AggObjTypeAxisAxisIntNDFrameTnpt)import_optional_dependency)SpecificationError)cache_readonly)find_stack_level)is_nested_object)is_dict_likeis_extension_array_dtypeis_list_likeis_numeric_dtypeis_sequence)CategoricalDtypeExtensionDtype)ABCDataFrame
ABCNDFrame	ABCSeries)generate_apply_looper)ensure_wrapped_if_datetimelike)	GeneratorHashableIterableMutableMappingSequence)	DataFrameIndexSeries)GroupBy)	Resampler)
BaseWindow
FrameApplyc
                    U R                  U5      nUS:X  a  [        n
OUS:X  a  [        n
[        U40 U	D6u  p  nUc   eW
" U UUUUUUUU	S9	$ )z=construct and return a row or column based frame apply objectr      )rawresult_typeby_rowengineengine_kwargsargskwargs)_get_axis_numberFrameRowApplyFrameColumnApplyreconstruct_func)objfuncaxisr5   r6   r7   r8   r9   r:   r;   klass_s               C/var/www/html/env/lib/python3.13/site-packages/pandas/core/apply.pyframe_applyrF   R   su     %Dqy	 $T4V4MAQ#
 
    c                     \ rS rSr% S\S'   SSSS.               SS jjr\R                  SS	 j5       r\R                      SS
 j5       r	\R                      SS j5       r
SS jrSS jrSS jrSS jrSS jr        S S jr    S!S jrSS jr          S"S jr      S#S jrSS jrSS jr        S$S jrS%S jrSrg)&Applyv   r   rB   compatpythonNr7   r8   r9   c                   Xl         X0l        USL d  US;   d   eXPl        U=(       d    SU l        U	=(       d    0 U l        X`l        Uc  0 OUU l        US;  a  [        S5      eX@l        X l	        g )NF)rK   _compat )Nreduce	broadcastexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'})
r@   r5   r7   r:   r;   r8   r9   
ValueErrorr6   rA   )
selfr@   rA   r5   r6   r7   r8   r9   r:   r;   s
             rE   __init__Apply.__init__y   sz     &,A"AAAJB	l#0#8RmEE= 
 '	rG   c                    g NrP   rU   s    rE   applyApply.apply       rG   c                    g rY   rP   rU   op_names     rE   agg_or_apply_list_likeApply.agg_or_apply_list_like        	rG   c                    g rY   rP   r_   s     rE   agg_or_apply_dict_likeApply.agg_or_apply_dict_like   rc   rG   c                   U R                   nU R                  nU R                  nU R                  n[	        U[
        5      (       a  U R                  5       $ [        U5      (       a  U R                  5       $ [        U5      (       a  U R                  5       $ [        U5      (       aG  [        R                  " U5      nU(       a*  U(       d#  U(       d  [        XU5        [        X5      " 5       $ g)z
Provide an implementation for the aggregators.

Returns
-------
Result of aggregation, or None if agg cannot be performed by
this method.
N)r@   rA   r:   r;   
isinstancestr	apply_strr   agg_dict_liker   agg_list_likecallablecomget_cython_funcwarn_alias_replacementgetattr)rU   r@   rA   r:   r;   fs         rE   agg	Apply.agg   s     hhyyyydC  >>##%%''$%%''D>>##D)Af&s!4s(( rG   c                j   U R                   nU R                  nU R                  nU R                  nU R                  nUR
                  S:H  nUR                  U5      S:X  a4  U(       a   eUR                  R                  " US/UQ70 UD6R                  $ [        U5      (       aq  [        U5      (       da  [        [        [           U5      nU(       a1  U Vs0 s H#  n[        R                  " U5      =(       d    UU_M%     nnOU Vs0 s H  oU_M     nn[        U5      (       a!  [        [         U5      nU R#                  U5      $ [        [        U5      n U R%                  U5      n	[-        U	[.        [0        45      (       a-  U	R2                  (       a  UR2                  (       d  [+        S5      e[-        U	[.        [0        45      (       a*  U	R4                  R7                  UR4                  5      (       d  [+        S5      eU	$ s  snf s  snf ! [&         a    e [(         a  n
[+        S5      U
eSn
A
ff = f)z
Transform a DataFrame or Series.

Returns
-------
DataFrame or Series
    Result of applying ``func`` along the given axis of the
    Series or DataFrame.

Raises
------
ValueError
    If the transform function fails or does not transform.
r4   r   zTransform function failedNzFunction did not transform)r@   rA   rB   r:   r;   ndimr<   T	transformr   r   r
   listr   rn   get_callable_namer   transform_dict_liketransform_str_or_callable	TypeError	ExceptionrT   rh   r$   r"   emptyindexequals)rU   r@   rA   rB   r:   r;   	is_seriesvcolresulterrs              rE   rx   Apply.transform   s    hhyyyyyyHHM	%*  =55??4<T<V<>>>l4&8&8_-t4DBFG$Q--a05Aq8$G-01ScT	S1.D++D11 OT*	C33D9F v	<899II899
 &9l";<<FLLDWDWIIE
 E
 9::E H1  	 	C89sB	Cs$   *HHH H2!H--H2c                r   SSK Jn  U R                  nU R                  nU R                  n[        U[        5      (       d   e[        U5      S:X  a  [        S5      eU R                  SX15      n0 nUR                  5        H.  u  pxUR                  USS9n	U	R                  " US/UQ70 UD6Xg'   M0     U" USS9$ )z3
Compute transform in the case of a dict-like func
r   concatz$No transform functions were providedrx   r4   rv   rB   )pandas.core.reshape.concatr   r@   r:   r;   rh   r#   lenrT   normalize_dictlike_argitems_gotitemrx   )
rU   rA   r   r@   r:   r;   resultsnamehowcolgs
             rE   r{   Apply.transform_dict_like  s     	6hhyy #z****t9>CDD**;B68ID<<1<-D NN3CDCFCGM & gA&&rG   c                   U R                   nU R                  nU R                  n[        U[        5      (       a  U R
                  " X!/UQ70 UD6$ U(       d@  U(       d9  [        R                  " U5      nU(       a  [        X!U5        [        X%5      " 5       $  UR                  " U4SU0UD6$ ! [         a    U" U/UQ70 UD6s $ f = f)z<
Compute transform in the case of a string or callable func
r:   )r@   r:   r;   rh   ri   
_apply_strrn   ro   rp   rq   r[   r~   )rU   rA   r@   r:   r;   rr   s         rE   r|   Apply.transform_str_or_callable'  s     hhyydC  ??3>t>v>>F##D)A&s!4s((	.99T7777 	.-d-f--	.s   B- -CCc                     U R                  SS9$ )zb
Compute aggregation in the case of a list-like argument.

Returns
-------
Result of aggregation.
rs   r`   )ra   rZ   s    rE   rl   Apply.agg_list_like>       **5*99rG   c                l   [        [        [           U R                  5      nU R                  n/ n/ nUR
                  S:X  a  U H  nUR                  UR                  SUS9n	[        X5      (       a  U R                  /U R                  QOU R                  n
[        X5      " U/U
Q70 UD6nUR                  U5        [        R                  " U5      =(       d    UnUR                  U5        M     Xv4$ / n[        U5       H  u  pUR                  USUR                   SS2U4   S9n	[        X5      (       a  U R                  /U R                  QOU R                  n
[        X5      " U/U
Q70 UD6nUR                  U5        UR                  U5        M     UR"                  R%                  U5      nXv4$ )a  
Compute agg/apply results for like-like input.

Parameters
----------
op_name : {"agg", "apply"}
    Operation being performed.
selected_obj : Series or DataFrame
    Data to perform operation on.
kwargs : dict
    Keyword arguments to pass to the functions.

Returns
-------
keys : list[Hashable] or Index
    Index labels for result.
results : list
    Data for result. When aggregating with a Series, this can contain any
    Python objects.
r4   )rv   subsetN)r
   ry   r   rA   r@   rv   r   r   include_axisrB   r:   rq   appendrn   rz   	enumerateiloccolumnstake)rU   r`   selected_objr;   rA   r@   r   keysar   r:   new_resr   indicesr   r   s                   rE   compute_list_likeApply.compute_list_likeH  s   4 D)4995hh !||L$5$5Al|S $G22 YY++ 
 "$0DTDVDw' ,,Q/41D! < } G'5
||Ca8I8I!U(8S|T $G22 YY++ 
 "$0GGGw'u% 6  '',,W5D}rG   c                    SSK Jn  U R                  n U" X!SSS9$ ! [         a?  nSSKJn  U" X!UR                  S9n[        U5      (       a  [        S5      UeUs S nA$ S nAff = f)	Nr   r   r4   F)r   rB   sortr.   r   r   z3cannot combine transform and aggregation operations)	r   r   r@   r}   pandasr.   r   r   rT   )rU   r   r   r   r@   r   r.   r   s           rE   wrap_results_list_likeApply.wrap_results_list_like  sn     	6hh	'15AA 
	 &Gchh?F'' I M
	s    
A%4A A% A%c                     U R                  SS9$ )zb
Compute aggregation in the case of a dict-like argument.

Returns
-------
Result of aggregation.
rs   r   )re   rZ   s    rE   rk   Apply.agg_dict_like  r   rG   c                   SSK JnJn  U R                  n[	        XuU45      n[        [        U R                  5      n	U R                  XU	5      n	UR                  S:H  =(       a0    UR                  R                  5       [        UR                  5      :  n
UR                  S:X  a`  UR                  USS9nU	R                  5        VVs/ s H  u  p[        X5      " U40 UD6PM     nnn[!        U	R#                  5       5      nX4$ U(       d  U
(       a  / n/ nU	R                  5        H  u  nnUR                  R%                  U/5      nUR                  R'                  U5      n[)        [         5      n[+        UU5       H  u  nnUU   R-                  U5        M     UR                  5        VVVs/ s H1  u  nnU  H$  n[        UR/                  USS9U5      " U40 UD6PM&     M3     nnnnUU/[        U5      -  -  nUU-  nM     X4$ U	R                  5        VVs/ s H'  u  nn[        UR                  USS9U5      " U40 UD6PM)     nnn[!        U	R#                  5       5      nX4$ s  snnf s  snnnf s  snnf )a3  
Compute agg/apply results for dict-like input.

Parameters
----------
op_name : {"agg", "apply"}
    Operation being performed.
selected_obj : Series or DataFrame
    Data to perform operation on.
selection : hashable or sequence of hashables
    Used by GroupBy, Window, and Resample if selection is applied to the object.
kwargs : dict
    Keyword arguments to pass to the functions.

Returns
-------
keys : list[hashable]
    Index labels for result.
results : list
    Data for result. When aggregating with a Series, this can contain any
    Python object.
r   DataFrameGroupBySeriesGroupBy   r4   r   r   )pandas.core.groupby.genericr   r   r@   rh   r
   r   rA   r   rv   r   nuniquer   r   r   rq   ry   r   get_indexer_forr   r   zipr   _ixs)rU   r`   r   	selectionr;   r   r   r@   
is_groupbyrA   is_non_unique_colr   rD   r   r   r   keyr   labelslabel_to_indicesr   labelindicekey_datas                           rE   compute_dict_likeApply.compute_dict_like  sm   :	

 hh%FG
OTYY/**7$G " K$$,,.\5I5I1JJ 	
 !<<	<2DKO::<X<wt-c<V<<GX		$D: }9  1 GD JJLS&..>>uE%--227;#.t#4 $'$8LE5$U+2259 %9
 +;*@*@*B*Bw") L--f1-=wGVvV") W*B   H--8# ). }	 !%

 ,HC Sq17;CJ6J ,   		$D}= Ys   I*08I0
.I7c                   SSK Jn  SSKJn  U R                  nU Vs/ s H  n[        U[        5      PM     nn[        U5      (       a  [        [        X#5      5      n	U V
s/ s H  oU
   R                  (       a  M  U
PM     nn
U/ :w  a  UOUnUR                  S:X  a/  U" U5      nUR                  UR                  R                  5        Un[        U[        5      (       a  SOSnU" U V
s0 s H  oX   _M	     sn
UUS9nU$ [!        U5      (       a  [#        S5      eSSK Jn  UR                  S:X  a  ['        S	U5      nUR(                  nOS nU" X2US
9nU$ s  snf s  sn
f s  sn
f )Nr   r-   r   r   r4   )rB   r   zLcannot perform both aggregation and transformation operations simultaneouslyr   r.   r   )r   r-   r   r   r@   rh   r#   alldictr   r   rv   
_set_namesr   namesr$   anyrT   r.   r
   r   )rU   r   result_indexresult_datar-   r   r@   r
is_ndframer   kkeys_to_usekturB   r   r.   r   s                    rE   wrap_results_dict_likeApply.wrap_results_dict_like  sV    	!5hh :EEAjJ/
Ez??3|9:G&2Kl!*:J:J1lKK)4):+K  A%K(|3399:!!+C!;!;AD(341GJ4 F2 ) __!  & xx1}8S)xxK$GFQ F
 L 5s   E!E<E,E"c                   [        [        U R                  5      nU R                  nSSKJnJn  [        X!S5      n[        U5      (       a  [        R                  " U5      n/ UR                  QUR                  Q7nU R                  S:w  a  SU;  d  US;   a  [        SU S35      eSU;   ar  [        X$U45      (       aG  SnUS;   a  U R                  R                  nXR                  :w  a  U R                  U R                   S'   OU R                  U R                   S'   U R"                  " X!/U R                  Q70 U R                   D6$ )	zQ
Compute apply in case of a string.

Returns
-------
result: Series or DataFrame
r   r   NrB   )corrwithskewz
Operation z does not support axis=1)idxmaxidxmin)r
   ri   rA   r@   r   r   r   rq   rm   inspectgetfullargspecr:   
kwonlyargsrB   rT   rh   r;   r   )	rU   rA   r@   r   r   methodsig	arg_namesdefault_axiss	            rE   rj   Apply.apply_str.  s    C#hh	
 D)F((0C4#((4S^^4IyyA~i'43G+G :dV3K!LMM"c3C#DEE
 $%L33 (,xx}}#yy0.2iiF+*.))DKK'sD499DDDrG   c                   U R                   S:X  a  [        S5      eU R                  S:X  aq  [        U R                  [
        5      (       aR  U R                  R                  R                  " U R                  S4SU R                  0U R                  D6R                  $ U R                  nU R                  n[        U5      (       a  U R                  SS9nOU R                  SS9n[        X140 UD6nU$ )z
Compute apply in case of a list-like or dict-like.

Returns
-------
result: Series, DataFrame, or None
    Result when self.func is a list-like or dict-like, None otherwise.
numbazIThe 'numba' engine doesn't support list-like/dict likes of callables yet.r4   r   r:   r[   r   )r8   NotImplementedErrorrB   rh   r@   r"   rw   r[   rA   r:   r;   r   re   ra   reconstruct_and_relabel_result)rU   rA   r;   r   s       rE   apply_list_or_dict_likeApply.apply_list_or_dict_like]  s     ;;'!%/ 
 99>j<@@88::##DIIqPtyyPDKKPRRRyy000AF000AF/GGrG   c                  ^	 US;   d   eUS:X  a:  [        U[        5      (       a%  [        S UR                  5        5       5      (       d%  [        S UR                  5        5       5      (       a  [	        S5      eUR
                  S:w  ad  SSKJn  U" [        UR                  5       5      5      R                  UR                  S	S
9n[        U5      S:  a  [        S[        U5       S35      e[        [        [        4m	[        U	4S jUR                  5        5       5      (       a9  0 nUR                  5        H!  u  px[        UT	5      (       d  U/Xg'   M  XU'   M#     UnU$ )z
Handler for dict-like argument.

Ensures that necessary columns exist if obj is a DataFrame, and
that a nested renamer is not passed. Also normalizes to all lists
when values consists of a mix of list and non-lists.
)r[   rs   rx   rs   c              3  <   #    U  H  u  p[        U5      v   M     g 7frY   )r   .0rD   r   s      rE   	<genexpr>/Apply.normalize_dictlike_arg.<locals>.<genexpr>  s     =LOO   c              3  <   #    U  H  u  p[        U5      v   M     g 7frY   )r   r   s      rE   r   r     s     ;lda,q//lr   znested renamer is not supportedr4   r   r   T)r   z
Column(s) z do not existc              3  @   >#    U  H  u  p[        UT5      v   M     g 7frY   )rh   )r   rD   xaggregator_typess      rE   r   r     s     H<41z!-..<s   )rh   r$   r   r   r   rv   r   r-   ry   r   
differencer   r   KeyErrortupler   )
rU   r   r@   rA   r-   colsnew_funcr   r   r   s
            @rE   r   Apply.normalize_dictlike_arg|  s%    3333 5L3	**=

===;djjl;;;$%FGG88q=$diik*+66s{{6ND4y1}DJ<}EFF %. H4::<HHH(*H

!!%566#$#HK"#QK	 %
 DrG   c                   [        U[        5      (       d   e[        X5      (       a_  [        X5      n[	        U5      (       a  U" U0 UD6$ [        U5      S:X  d   e[        U Vs/ s H  ofS;  d  M
  UPM     sn5      S:X  d   eU$ [        [        U5      (       a-  [        US5      (       a  [        [        U5      nU" U/UQ70 UD6$ SU S[        U5      R                   S3n[        U5      es  snf )z
if arg is a string, then try to operate on it:
- try to find a function (or attribute) on obj
- try to find a numpy function
- raise
r   r   	__array__'z' is not a valid function for 'z' object)
rh   ri   hasattrrq   rm   r   nptype__name__AttributeError)rU   r@   rA   r:   r;   rr   kwargmsgs           rE   r   Apply._apply_str  s     $$$$$3"A{{$)&)) t9>!>6K6%(5J6KLPQQQQHR73#<#<D!AS*4*6**dV:49;M;M:NhWC %% Ls   %	C02C0)	r:   r7   r8   r9   rA   r;   r@   r5   r6   )r@   r   rA   r   r5   boolr6   
str | Noner7   #Literal[False, 'compat', '_compat']r8   ri   r9   dict[str, bool] | NonereturnNoner  DataFrame | Seriesr`   Literal['agg', 'apply']r  r  )r  zDataFrame | Series | None)r  r,   )r`   r  r   Series | DataFramer;   dict[str, Any]r  z(tuple[list[Hashable] | Index, list[Any]])r   Iterable[Hashable]r   zlist[Series | DataFrame])
r`   r  r   r  r   zHashable | Sequence[Hashable]r;   r  r  z tuple[list[Hashable], list[Any]])r   r  r   zlist[Hashable]r   ry   )r   ri   r@   r  rA   r   r  r   )rA   ri   )r  
__module____qualname____firstlineno____annotations__rV   abcabstractmethodr[   ra   re   rs   rx   r{   r|   rl   r   r   rk   r   r   rj   r   r   r   __static_attributes__rP   rG   rE   rI   rI   v   s   
M 7?04!! ! 	!
  ! 4! ! .! 
!F 	  	.	 
 	.	 
@AF'0..:@(@ )@ 	@
 
2@D&1I*:M(M )M 1	M
 M 
*M^4(4 %4 	4l-E^>++/+7F+	+Z&rG   rI   )	metaclassc                  p    \ rS rSr% SrS\S'   \SS j5       r\SS j5       r    SS jr	    SS jr
S	rg
)NDFrameApplyi  z[
Methods shared by FrameApply and SeriesApply but
not GroupByApply or ResamplerWindowApply
r  r@   c                .    U R                   R                  $ rY   )r@   r   rZ   s    rE   r   NDFrameApply.index  s    xx~~rG   c                L    U R                   R                  U R                  5      $ rY   )r@   _get_agg_axisrB   rZ   s    rE   agg_axisNDFrameApply.agg_axis  s    xx%%dii00rG   c                r   U R                   nU R                  nUS:X  aW  [        U [        5      (       a  U R                  nO-[        U [
        5      (       a  U R                  (       a  SOSnOSn0 UESU0En[        USS5      S:X  a  [        S5      eU R                  XU5      u  pVU R                  XV5      nU$ )	Nr[   rO   Fr7   rB   r   r4   "axis other than 0 is not supported)
r@   r;   rh   r2   r7   SeriesApplyrq   r   r   r   )rU   r`   r@   r;   r7   r   r   r   s           rE   ra   #NDFrameApply.agg_or_apply_list_like  s     hhg$
++D+..&*kku11&1F3"a'%&JKK..wVD,,T;rG   c                   US;   d   eU R                   n0 nUS:X  a(  U R                  (       a  SOSnUR                  SU05        [        USS5      S:X  a  [	        S	5      eS nU R                  XXS5      u  pgU R                  X&U5      nU$ )
Nrs   r[   r[   rO   Fr7   rB   r   r4   r(  )r@   r7   updaterq   r   r   r   )	rU   r`   r@   r;   r7   r   r   r   r   s	            rE   re   #NDFrameApply.agg_or_apply_dict_like  s     ****hhg"&++Y5FMM8V,-3"a'%&JKK	$($:$:)%
! ,,SLrG   rP   Nr  r-   r  )r  r  r  r  __doc__r  propertyr   r%  ra   re   r  rP   rG   rE   r   r     s_    
 
  1 1.	..	rG   r   c                  F  ^  \ rS rSr% S\S'   SSSS.               SU 4S jjjr\\R                  SS	 j5       5       r	\\R                  SS
 j5       5       r
\\R                  S S j5       5       r\\R                  \R                   S! S"S jj5       5       5       r\R                  S 5       rS r\R                        S#S j5       r\SS j5       r\SS j5       r\S 5       rS$S jrU 4S jrS rS%S jrS&S jrS rS'S jrS rS#S jrS$U 4S jjr Sr!U =r"$ )(r2   i  r,   r@   FrL   NrM   c               d   > USLa  US:w  a  [        SU S35      e[        T
U ]	  UUUUUUUUU	S9	  g )NFrK   zby_row=z not allowed)r7   r8   r9   r:   r;   )rT   superrV   )rU   r@   rA   r5   r6   r7   r8   r9   r:   r;   	__class__s             rE   rV   FrameApply.__init__  sU     6X#5wvhl;<<' 	 
	
rG   c                    g rY   rP   rZ   s    rE   r   FrameApply.result_index#       	rG   c                    g rY   rP   rZ   s    rE   result_columnsFrameApply.result_columns(  r9  rG   c                    g rY   rP   rZ   s    rE   series_generatorFrameApply.series_generator-  r9  rG   c                    g rY   rP   )rA   nogilnopythonparallels       rE   generate_numba_apply_func$FrameApply.generate_numba_apply_func2  s     	rG   c                    g rY   rP   rZ   s    rE   apply_with_numbaFrameApply.apply_with_numba:  r]   rG   c                    U R                   R                  R                  5        HF  u  p[        U5      (       d  [	        SU SU S35      e[        U5      (       d  M9  [	        SU S35      e   g )NzColumn z# must have a numeric dtype. Found 'z	' insteadzM is backed by an extension array, which is not supported by the numba engine.)r@   dtypesr   r   rT   r   )rU   colnamedtypes      rE   validate_values_for_numba$FrameApply.validate_values_for_numba>  s|    "hhoo335NG#E** gY '#WI/  (.. gY 'B C  6rG   c                    g rY   rP   rU   r   	res_indexs      rE   wrap_results_for_axis FrameApply.wrap_results_for_axisL  rc   rG   c                    U R                   $ rY   )r;  rZ   s    rE   res_columnsFrameApply.res_columnsT  s    """rG   c                .    U R                   R                  $ rY   )r@   r   rZ   s    rE   r   FrameApply.columnsX  s    xxrG   c                .    U R                   R                  $ rY   )r@   valuesrZ   s    rE   rZ  FrameApply.values\  s    xxrG   c                   [        U R                  5      (       a+  U R                  S:X  a  [        S5      eU R	                  5       $ [        U R                  5      S:X  a)  [        U R                  5      S:X  a  U R                  5       $ [        U R                  [        5      (       a+  U R                  S:X  a  [        S5      eU R                  5       $ [        U R                  [        R                  5      (       a  U R                  S:X  a  [        S5      e[        R                  " SS9   U R                  R                   R#                  SU R                  S	9nS
S
S
5        U R                  R%                  WUR&                  S9$ U R(                  S:X  a6  U R                  S:X  a  [        S5      eU R+                  U R                  5      $ [-        U R                  R.                  5      (       d  U R                  5       $ U R0                  (       a$  U R3                  U R                  U R4                  S9$ U R7                  5       $ ! , (       d  f       N= f)zcompute the resultsr   z9the 'numba' engine doesn't support lists of callables yetr   zJthe 'numba' engine doesn't support using a string as the callable functionzOthe 'numba' engine doesn't support using a numpy ufunc as the callable functionignorer   r[   )rA   N)axesrR   z:the 'numba' engine doesn't support result_type='broadcast'r8   r9   )r   rA   r8   r   r   r   r   r   apply_empty_resultrh   ri   rj   r  ufuncerrstater@   _mgrr[   _constructor_from_mgrr_  r6   apply_broadcastr   shaper5   	apply_rawr9   apply_standardrU   r   s     rE   r[   FrameApply.apply`  s    		""{{g%)O  //11 t||!c$**o&:**,, dii%%{{g%)8  >>## 		288,,{{g%)C  *((----gDII-F + 8811'1MM {*{{g%)P  ''11 TXX^^$$**,, XX>>DDVDV>WW""$$+ +*s   */I
Ic                  > U R                   nU R                  nU R                  S:X  a  U R                   OU R                   R                  U l         SU l        S n [        TU ]  5       nXl         X l        US:X  a  Ub  UR                  OUnUc>  U R                   R
                  " U R                  U4SU R                  0U R                  D6nU$ ! Xl         X l        f = f)Nr   r4   r:   )	r@   rB   rw   r4  rs   r[   rA   r:   r;   )rU   r@   rB   r   r5  s       rE   rs   FrameApply.agg  s    hhyy  $yyA~488488::		W[]FHI19!'!3VXXF>XX^^DIItS$))St{{SF HIs   C Cc                   [        U R                  5      (       d   eU R                  S;  a  U R                  R	                  5       $ U R                  S:H  nSSKJn  U(       d   U R                  S:X  a>  U R                  " U" / [        R                  S9/U R                  Q70 U R                  D6nOGU R                  " U" U R                  [        R                  S9/U R                  Q70 U R                  D6n[        X25      (       + nU(       a  [        U R                   5      (       a>  U R                  " U" / [        R                  S9/U R                  Q70 U R                  D6nO[        R"                  nU R                  R%                  X0R                   S9$ U R                  R	                  5       $ ! [         a     Nf = f)z
we have an empty result; at least 1 axis is 0

we will try to apply the function to an empty
series in order to see if this is a reduction function
)rQ   NrQ   r   r   rL  )r   rL  r   )rm   rA   r6   r@   copyr   r.   rB   r  float64r:   r;   r   rh   r~   r   r%  nan_constructor_sliced)rU   should_reducer.   r   s       rE   ra  FrameApply.apply_empty_result  sg    		"""" #3388==?" ((H4!:99>		r47;yyDHKKA 		T\\D ++A %/q$9 94==!!IIfRrzz:VTYYV$++VFF88///GG88==?"  s   $BF5 5
GGc                    S nUS:X  aQ  Uc  0 OUn[        U R                  40 UD6nU" U R                  U R                  5      n[        R
                  " U5      nOT[        R                  " U" U R                  5      U R                  U R                  /U R                  Q70 U R                  D6nUR                  S:X  a.  U R                  R                  XPR                  U R                  S9$ U R                  R                  XPR                  S9$ )z$apply to the values as a numpy arrayc                   ^  U 4S jnU$ )zi
Wrap user supplied function to work around numpy issue.

see https://github.com/numpy/numpy/issues/8352
c                 t   > T" U 0 UD6n[        U[        5      (       a  [        R                  " U[        S9nU$ )Nro  )rh   ri   r  arrayobject)r:   r;   r   rA   s      rE   wrapper<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapper  s4    t.v.fc**XXfF;FrG   rP   )rA   r|  s   ` rE   wrap_function+FrameApply.apply_raw.<locals>.wrap_function  s     NrG   r   r   r   r   rp  )r%   rA   rZ  rB   r  squeezeapply_along_axisr:   r;   rv   r@   _constructorr   r   rt  r%  )rU   r8   r9   r~  	nb_looperr   s         rE   rh  FrameApply.apply_raw  s    	 W"/"7B]M .		*I t{{DII6FZZ'F((dii(		 	
 ++F ;;!88((zz4<<(XX88//mm/LLrG   c                >   [        U R                  5      (       d   e[        R                  " UR                  5      nUR
                  S   n[        UR                  5       H  u  pEU R                  " X   /U R                  Q70 U R                  D6n[        R                  " U5      R                  nUS:  a  [        S5      eUS:X  a  U[        U5      :w  a  [        S5      eXbS S 2U4'   M     U R                  R                  X!R                   UR                  S9nU$ )Nr   r4   ztoo many dims to broadcastzcannot broadcast resultr  )rm   rA   r  
empty_likerZ  rg  r   r   r:   r;   asarrayrv   rT   r   r@   r  r   )	rU   targetresult_valuesresult_compareir   resaresr   s	            rE   rf  FrameApply.apply_broadcast	  s    		""""fmm4  a/FA))FKC$))Ct{{CC::c?''D ax !=>>qy!SX-$%>??"%!Q$ 0 &&v~~ ' 
 rG   c                    U R                   S:X  a  U R                  5       u  pOU R                  5       u  pU R                  X5      $ )NrL   )r8   apply_series_generatorapply_series_numbawrap_resultsrP  s      rE   ri  FrameApply.apply_standard%  sE    ;;("!%!<!<!>GY!%!8!8!:G   44rG   c                   [        U R                  5      (       d   eU R                  nU R                  n0 n[	        SS 5         [        U5       H]  u  pEU R                  " U/U R                  Q70 U R                  D6X4'   [        X4   [        5      (       d  MJ  X4   R                  SS9X4'   M_     S S S 5        X24$ ! , (       d  f       X24$ = f)Nzmode.chained_assignmentF)deep)rm   rA   r>  r   r   r   r:   r;   rh   r$   rq  )rU   
series_genrQ  r   r  r   s         rE   r  !FrameApply.apply_series_generator.  s    		""""**
%%	5t<!*-!YYqD499DD
gj)44 ")e!<GJ . = !! =< !!s   AB;B;;
Cc                J   U R                   R                  SS5      (       a  [        S5      eU R                  R                  R
                  (       a  U R                  R
                  (       d  [        S5      eU R                  5         U R                  5       nXR                  4$ )NrC  FzAParallel apply is not supported when raw=False and engine='numba'zBThe index/columns must be unique when raw=False and engine='numba')
r9   getr   r@   r   	is_uniquer   rM  rG  r   rj  s     rE   r  FrameApply.apply_series_numbaA  s    !!*e44%S  xx~~''t||/E/E%T  	&&('')))))rG   c                   SSK Jn  [        U5      S:  a*  SU;   a$  [        US   5      (       a  U R	                  X5      $ U R
                  R                  n[        U5      S:X  a  XCL a  U" U[        R                  S9nOU" U5      nX%l	        U$ )Nr   r   ro  )
r   r.   r   r   rR  r@   rt  r  rr  r   )rU   r   rQ  r.   constructor_slicedr   s         rE   r  FrameApply.wrap_resultsN  s    ! w<!WWQZ1H1H--gAA "XX99w<1!3!='rzzBF'0F rG   c                   > U R                   S:X  a>  U R                  nUR                  U R                     nUR	                  X R
                  S9$ [        TU ]  5       $ )Nsizerp  )rA   r@   rg  rB   rt  r%  r4  rj   )rU   r@   valuer5  s      rE   rj   FrameApply.apply_strc  sR     99((CIIdii(E**5*FFw ""rG   )rB   r@   )r@   r   rA   r   r5   r
  r6   r  r7   Literal[False, 'compat']r8   ri   r9   r  r  r  r/  r  zGenerator[Series, None, None]TTFr  z5Callable[[npt.NDArray, Index, Index], dict[int, Any]]r   ResTyperQ  r-   r  r  r  )rL   Nr  r,   r  r,   )r  ztuple[ResType, Index])#r  r  r  r  r  rV   r1  r  r  r   r;  r>  staticmethod	functoolscacherD  rG  rM  rR  rU  r   r   rZ  r[   rs   ra  rh  rf  ri  r  r  r  rj   r  __classcell__r5  s   @rE   r2   r2     s   	N ,104

 
 	

  
 )
 
 .
 

 
<          __27	>   
 	  	+0	  # #      4%l.,#\,M\85"&**# #rG   c                      \ rS rSr% SrS\S'   \SS j5       r\\	R                   S SS jj5       5       rSS jr\SS j5       r\SS	 j5       r      SS
 jrSrg)r=   in  r   r   rB   c                T   ^  U 4S j[        [        T R                  5      5       5       $ )Nc              3  X   >#    U  H  nTR                   R                  US S9v   M!     g7f)r4   r   N)r@   r   )r   r  rU   s     rE   r   1FrameRowApply.series_generator.<locals>.<genexpr>s  s$     K2JQaa(2Js   '*)ranger   r   rZ   s   `rE   r>  FrameRowApply.series_generatorq  s    K%DLL8I2JKKrG   c                   ^^^ [        S5      nSSKJm  SSKJm  UR
                  R                  U 5      mUR                  XUS9UUU4S j5       nU$ )Nr   r   r   maybe_cast_strrA  rB  rC  c           	        > 0 n[        U R                  S   5       H$  nT" U S S 2U4   UT" X   5      S9nT" U5      X4'   M&     U$ )Nr4   r   )r  rg  )	rZ  	col_namesdf_indexr   jserr.   
jitted_udfr  s	         rE   
numba_func;FrameRowApply.generate_numba_apply_func.<locals>.numba_func  sS    G6<<?+1a4L~il7S (_
 , NrG   r   r   r.   pandas.core._numba.extensionsr  	extendingregister_jitablejit	rA   rA  rB  rC  r   r  r.   r  r  s	         @@@rE   rD  'FrameRowApply.generate_numba_apply_funcu  sV    
 +73! 	A__55d;
 
H	E	 
F	 rG   c           	     (   U R                   " [        [        U R                  5      40 U R                  D6nSSKJn  U R                  R                  nUR                  S:X  a  UR                  [        5      nU R                  R                  nUR                  S:X  a  UR                  [        5      nU" U5       o2" U5       n[        U" U R                  XC5      5      nS S S 5        S S S 5        W$ ! , (       d  f       N= f! , (       d  f       W$ = f)Nr   set_numba_datastring)rD  r
   r   rA   r9   r  r  r@   r   rL  astyper{  r   r   rZ  rU   nb_funcr  r   r   r  s         rE   rG  FrameRowApply.apply_with_numba  s    00499%
)-););
 	A;;("LL(E((""==H$nnV,G E"e^G-Dwt{{G;<C .E"
 .E-D""
s$   :DC1D1
C?	;D
Dc                    U R                   $ rY   r   rZ   s    rE   r   FrameRowApply.result_index      ||rG   c                    U R                   $ rY   rp  rZ   s    rE   r;  FrameRowApply.result_columns      zzrG   c                   U R                   S:X  a#  U R                  R                  U5      nX#l        U$ U R                   cH  [	        S UR                  5        5       5      (       a#  U R                  R                  U5      nX#l        U$  U R                  R                  US9n[        US   [        5      (       d=  [        UR                  5      [        U R                  5      :X  a  U R                  Ul        [        UR                  5      [        U5      :X  a  X$l        U$ ! [         a=  nS[        U5      ;   a(  U R                  R                  U5      nX#l        Us SnA$ e SnAff = f)zreturn the results for the rowsrQ   Nc              3  B   #    U  H  n[        U[        5      v   M     g 7frY   )rh   r   )r   r   s     rE   r   6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>  s      .
)9AJq$)9s   dataz%All arrays must be of the same lengthr   )r6   r@   rt  r   r   rZ  r  rT   ri   rh   r$   r   rU  r   )rU   r   rQ  r  r   r   s         rE   rR  #FrameRowApply.wrap_results_for_axis  s4   
 x'((..w7C!IJ%# .
)0)9.
 +
 +

 ((..w7C!IJ
	XX***8F '!*i006<< C(8(8$99#//v~~#i.0&N#  	6#c(B hh227;%	
	s$   
D" "
E),1E$E)#E$$E)rP   Nr  r  r  r  zdict[int, Any]r/  r  )r  r  r  r  rB   r  r1  r>  r  r  r  rD  rG  r   r;  rR  r  rP   rG   rE   r=   r=   n  s    D'L L __27	>  6(    ''+0'	'rG   r=   c                     ^  \ rS rSr% SrS\S'   SU 4S jjr\SS j5       r\	\
R                   S SS jj5       5       rSS jr\SS	 j5       r\SS
 j5       r      SS jrSS jrSrU =r$ )r>   i  r4   r   rB   c                N   > [         TU ]  UR                  5      nUR                  $ rY   )r4  rf  rw   )rU   r  r   r5  s      rE   rf   FrameColumnApply.apply_broadcast  s    (2xxrG   c              #    #    U R                   n[        U5      n[        U5      S:  d   eU R                  R	                  SSS9nUR
                  nUR                  S   R                  R                  5       n[        UR                  [        5      (       a:  U R                  n[        [        U5      5       H  nUR	                  USS9v   M     g [        XR                  5       Hh  u  pxX2l        UR                  U5        [         R#                  USU5        U(       d*  [%        UR                  S   5      UR                  S   l        Uv   Mj     g 7f)Nr   r   _name)rZ  r&   r   r@   r   rd  blocksrefshas_referencerh   rL  r!   r  r   r   
set_valuesr{  __setattr__r   )	rU   rZ  r  mgris_viewr@   r  arrr   s	            rE   r>  !FrameColumnApply.series_generator  s    /76{Q hhmmAAm&hh**Q-$$224cii00 ((C3s8_hhqqh)) % !4	s#""36 *9A)GCJJqM&	 5s   EEc                   ^^^ [        S5      nSSKJm  SSKJm  UR
                  R                  U 5      mUR                  XUS9UUU4S j5       nU$ )Nr   r   r   r  r  c           	        > 0 n[        U R                  S   5       H-  nT" X   R                  5       UT" X$   5      S9nT" U5      X4'   M/     U$ )Nr   r   )r  rg  rq  )	rZ  col_names_indexr   r   r  r  r.   r  r  s	         rE   r  >FrameColumnApply.generate_numba_apply_func.<locals>.numba_func  sZ    G 6<<?+ INN$)'1
 (_
 , NrG   r  r  s	         @@@rE   rD  *FrameColumnApply.generate_numba_apply_func  sQ    
 +73!@__55d;
	H	E	 
F	  rG   c           	     x   U R                   " [        [        U R                  5      40 U R                  D6nSSKJn  U" U R                  R                  5       o2" U R                  5       n[        U" U R                  XC5      5      nS S S 5        S S S 5        W$ ! , (       d  f       N= f! , (       d  f       W$ = f)Nr   r  )rD  r
   r   rA   r9   r  r  r@   r   r   r   rZ  r  s         rE   rG  !FrameColumnApply.apply_with_numba!  s    00499%
)-););
 	A DHHNN+unLL7
wt{{G;<C7
+
 
7
 7
++
 
s$   B**BB*
B'	#B**
B9c                    U R                   $ rY   rp  rZ   s    rE   r   FrameColumnApply.result_index1  r  rG   c                    U R                   $ rY   r  rZ   s    rE   r;  FrameColumnApply.result_columns5  r  rG   c                    U R                   S:X  a  U R                  X5      nU$ [        US   [        5      (       d#  U R                  R                  U5      nX#l        U$ U R                  X5      nU$ )z"return the results for the columnsrS   r   )r6   infer_to_same_shaperh   r$   r@   rt  r   rU   r   rQ  r   s       rE   rR  &FrameColumnApply.wrap_results_for_axis9  ss     x'--gAF  GAJ	22XX11':F$L  --gAFrG   c                z    U R                   R                  US9nUR                  nX#l        UR	                  SS9nU$ )z7infer the results to the same shape as the input objectr  Frq  )r@   r  rw   r   infer_objectsr  s       rE   r  $FrameColumnApply.infer_to_same_shapeN  sC    &&G&4 ! %%5%1rG   rP   r  r  r  r  r  r/  r  )r   r  rQ  r-   r  r,   )r  r  r  r  rB   r  rf  r1  r>  r  r  r  rD  rG  r   r;  rR  r  r  r  r  s   @rE   r>   r>     s    D' ! !F __27	>  8     +0	* rG   r>   c                     ^  \ rS rSr% S\S'   SrS\S'   S\S'   \R                  S	S
.         SU 4S jjjrSS jr	U 4S jr
SS jrS rSS jrSrU =r$ )r)  i\  r.   r@   r   r   rB   r  r7   rK   )convert_dtyper7   c          
        > U[         R                  L a  SnO"[        R                  " S[        [        5       S9  X0l        [        TU ]!  UUSS UUUS9  g )NTzthe convert_dtype parameter is deprecated and will be removed in a future version.  Do ``ser.astype(object).apply()`` instead if you want ``convert_dtype=False``.
stacklevelF)r5   r6   r7   r:   r;   )	r   
no_defaultwarningswarnFutureWarningr   r  r4  rV   )rU   r@   rA   r  r7   r:   r;   r5  s          rE   rV   SeriesApply.__init__a  sa     CNN* MMM? +- + 	 	
rG   c                j   U R                   n[        U5      S:X  a  U R                  5       $ [        U R                  5      (       a  U R                  5       $ [        U R                  [        5      (       a  U R                  5       $ U R                  S:X  a  U R                  5       $ U R                  5       $ )Nr   rO   )r@   r   ra  r   rA   r   rh   ri   rj   r7   apply_compatri  rU   r@   s     rE   r[   SeriesApply.apply  s    hhs8q=**,, 		""//11dii%%>>##;;)#$$&& ""$$rG   c                  > [         TU ]  5       nUc  U R                  nU R                  n[	        U5      (       d   e UR
                  " U4SU R                  0U R                  D6nSU S[        U5      R                   S[        U5      R                   S3n[        R                  " U[        [        5       S9  U$ U$ ! [        [        [         4 a$    U" U/U R                  Q70 U R                  D6n U$ f = f)Nr:   zusing z in z3.agg cannot aggregate and has been deprecated. Use z&.transform to keep behavior unchanged.r  )r4  rs   r@   rA   rm   r[   r:   r;   r  r  r  r  r  r   rT   r  r}   )rU   r   r@   rA   r  r5  s        rE   rs   SeriesApply.agg  s    >((C99DD>>!>

Q4GdiiG4;;G
 TF$tCy'9'9&: ;004S	0B0B/C D/0 
 c==M=OPv 	: >c=DII== >s   )B? ?5C87C8c                ~    U R                   nUR                  UR                  UR                  S9R	                  USS9$ )N)rL  r   r[   r   )r@   r  rL  r   __finalize__r  s     rE   ra  SeriesApply.apply_empty_result  sA    hhciisyyANN O 
 	
rG   c                n   U R                   nU R                  n[        U5      (       aO  [        R                  " U5      nU(       a2  U R
                  (       d!  U R                  (       d  UR                  USS9$  UR                  USS9nU$ ! [        [        [        4 a    UR                  USS9n U$ f = f)zcompat apply method for funcs in listlikes and dictlikes.

 Used for each callable when giving listlikes and dictlikes of callables to
 apply. Needed for compatibility with Pandas < v2.1.

.. versionadded:: 2.1.0
F)r7   rK   )r@   rA   rm   rn   ro   r:   r;   r[   rT   r  r}   )rU   r@   rA   rr   r   s        rE   r  SeriesApply.apply_compat  s     hhyyD>>##D)A4;;yyey44	3YYtHY5F  NI6 	3YYtEY2F	3s   9B %B43B4c                F  ^ ^ [        [        T R                  5      mT R                  n[	        T[
        R                  5      (       a>  [
        R                  " SS9   T" U/T R                  Q70 T R                  D6sS S S 5        $ T R                  (       d   T" U/T R                  Q70 T R                  D6$ T R                  (       d  T R                  (       a  UU 4S jnOTn[	        UR                  [        5      (       a  SOS nUR                  X#T R                  S9n[        U5      (       a;  [	        US   [         5      (       a#  UR#                  [%        U5      UR&                  S9$ UR)                  XAR&                  S9R+                  USS9$ ! , (       d  f       N= f)	Nr]  r^  c                D   > T" U /TR                   Q70 TR                  D6$ rY   )r:   r;   )r   rA   rU   s    rE   curried+SeriesApply.apply_standard.<locals>.curried  s     A9		9T[[99rG   )mapper	na_actionconvertr   rp  r[   r  )r
   r   rA   r@   rh   r  rb  rc  r:   r;   r7   rL  r    _map_valuesr  r   r$   _constructor_expanddimry   r   r  r  )rU   r@   r  actionmappedrA   s   `    @rE   ri  SeriesApply.apply_standard  sD   Hdii(hhdBHH%%*C;$));t{{; +*7dii74;;7799: G (		3CDD$d6H6H ! 
 v;;:fQi;; --d6l#))-LL##F))#<IIG J  9 +*s    F
F )r  )
r@   r.   rA   r   r  zbool | lib.NoDefaultr7   r  r  r  r  )r  r.   )r  r  r  r  r  rB   r   r  rV   r[   rs   ra  r  ri  r  r  r  s   @rE   r)  r)  \  s}    	KD'// /2nn6>

 

 ,
 4
 

 
@%(2
,$ $rG   r)  c                  t   ^  \ rS rSr% S\S'         S
U 4S jjrS rS r    SS jr    SS jr	S	r
U =r$ )GroupByApplyi  z GroupBy | Resampler | BaseWindowr@   c          	        > UR                  5       nUR                  R                  UR                  SS5      5      U l        [
        TU ]  UUSS UUS9  g )NrB   r   Fr5   r6   r:   r;   )rq  r@   r<   r  rB   r4  rV   rU   r@   rA   r:   r;   r5  s        rE   rV   GroupByApply.__init__  sU     GG,,VZZ-BC	 	 	
rG   c                    [         erY   r   rZ   s    rE   r[   GroupByApply.apply      !!rG   c                    [         erY   r)  rZ   s    rE   rx   GroupByApply.transform
  r+  rG   c           	        U R                   nU R                  nUS:X  a  0 UESS0En[        USS5      S:X  a  [        S5      eUR                  R
                  S:X  a  UR                  nOUR                  n[        R                  " USS	[        US5      S
9   U R                  XU5      u  pVS S S 5        U R                  WW5      nU$ ! , (       d  f       N"= f)Nr[   r7   FrB   r   r4   r(  as_indexT	condition)r@   r;   rq   r   _selected_objrv   _obj_with_exclusionsrn   temp_setattrr  r   r   )rU   r`   r@   r;   r   r   r   r   s           rE   ra   #GroupByApply.agg_or_apply_list_like  s     hhg00%0F3"a'%&JKK!!Q&,,L33L TWS*-E
 !227&QMD
 ,,T7;
 
s   C
Cc           	        SSK JnJn  US;   d   eU R                  n0 nUS:X  a(  U R                  (       a  SOSnUR                  SU05        [        USS5      S	:X  a  [        S
5      eUR                  nUR                  n[        XBU45      n	U	(       aK  U R                  R                  SS 5      n
U R                  R                  SS 5      nUR                  XS.5        [        R                  " USS[        US5      S9   U R!                  XX5      u  pS S S 5        U R#                  UWW5      nU$ ! , (       d  f       N#= f)Nr   r   r,  r[   rO   Fr7   rB   r4   r(  r8   r9   r`  r/  Tr0  )r   r   r   r@   r7   r-  rq   r   r2  
_selectionrh   r;   r  rn   r4  r  r   r   )rU   r`   r   r   r@   r;   r7   r   r   r   r8   r9   r   r   r   s                  rE   re   #GroupByApply.agg_or_apply_dict_like'  s+   	

 ****hhg"&++Y5FMM8V,-3"a'%&JKK((NN	%FG
 [[__Xt4F KKOOOTBMMMVLMTWS*-E
 )-(>(>y)%L
 ,,\<U
 
s   D33
Er   )r@   zGroupBy[NDFrameT]rA   r   r  r  r  )r  r  r  r  r  rV   r[   rx   ra   re   r  r  r  s   @rE   r#  r#    sc    	))

 
 

&"".	4%.%	% %rG   r#  c                  ^   ^  \ rS rSr% SrS\S'   S\S'         SU 4S jjrS rS	 rS
r	U =r
$ )ResamplerWindowApplyiO  r   r   rB   Resampler | BaseWindowr@   c          	     2   > [         [        U ]  UUSS UUS9  g )NFr%  )r4  r#  rV   r&  s        rE   rV   ResamplerWindowApply.__init__S  s+     	lD* 	+ 	
rG   c                    [         erY   r)  rZ   s    rE   r[   ResamplerWindowApply.applyd  r+  rG   c                    [         erY   r)  rZ   s    rE   rx   ResamplerWindowApply.transformg  r+  rG   rP   )r@   r;  rA   r   r  r  )r  r  r  r  rB   r  rV   r[   rx   r  r  r  s   @rE   r:  r:  O  sC    D'	
#
 
 

""" "rG   r:  c                   U SL =(       a    [        S0 UD6nSnSnU(       dO  [        U [        5      (       a,  [        U 5      [        [	        U 5      5      :  a  [        S5      eU c  [        S5      eU(       a  [        U5      u  pnU c   eX X44$ )aR  
This is the internal function to reconstruct func given if there is relabeling
or not and also normalize the keyword to get new order of columns.

If named aggregation is applied, `func` will be None, and kwargs contains the
column and aggregation function information to be parsed;
If named aggregation is not applied, `func` is either string (e.g. 'min') or
Callable, or list of them (e.g. ['min', np.max]), or the dictionary of column name
and str/Callable/list of them (e.g. {'A': 'min'}, or {'A': [np.min, lambda x: x]})

If relabeling is True, will return relabeling, reconstructed func, column
names, and the reconstructed order of columns.
If relabeling is False, the columns and order will be None.

Parameters
----------
func: agg function (e.g. 'min' or Callable) or list of agg functions
    (e.g. ['min', np.max]) or dictionary (e.g. {'A': ['min', np.max]}).
**kwargs: dict, kwargs used in is_multi_agg_with_relabel and
    normalize_keyword_aggregation function for relabelling

Returns
-------
relabelling: bool, if there is relabelling or not
func: normalized and mangled func
columns: tuple of column names
order: array of columns indices

Examples
--------
>>> reconstruct_func(None, **{"foo": ("col", "min")})
(True, defaultdict(<class 'list'>, {'col': ['min']}), ('foo',), array([0]))

>>> reconstruct_func("min")
(False, 'min', None, None)
NzFFunction names must be unique if there is no new column names assignedz4Must provide 'func' or tuples of '(column, aggfunc).rP   )is_multi_agg_with_relabelrh   ry   r   setr   r}   normalize_keyword_aggregation)rA   r;   
relabelingr   orders        rE   r?   r?   k  s    N E";"Ef"EJ&*G)-EdD!!c$i#c$i.&@ %  <RSS  = 
u W++rG   c                 l    [        S U R                  5        5       5      =(       a    [        U 5      S:  $ )a8  
Check whether kwargs passed to .agg look like multi-agg with relabeling.

Parameters
----------
**kwargs : dict

Returns
-------
bool

Examples
--------
>>> is_multi_agg_with_relabel(a="max")
False
>>> is_multi_agg_with_relabel(a_max=("a", "max"), a_min=("a", "min"))
True
>>> is_multi_agg_with_relabel()
False
c              3  l   #    U  H*  n[        U[        5      =(       a    [        U5      S :H  v   M,     g7f)r   N)rh   r   r   )r   r   s     rE   r   ,is_multi_agg_with_relabel.<locals>.<genexpr>  s'     M_z!U#3A!3_s   24r   )r   rZ  r   )r;   s    rE   rC  rC    s-    * MV]]_MM FarG   c           
        SSK Jn  [        [        5      n/ n[        [	        U R                  5       6 5      u  pEU HH  u  pgX&   R                  U5        UR                  U[        R                  " U5      =(       d    U45        MJ     [        U5      nUR                  5        VV	Vs/ s H0  u  piU	  H$  nU[        R                  " U5      =(       d    U4PM&     M2     n
n	nn[        U
5      nU" U5      R                  U5      nX$U4$ s  snn	nf )a  
Normalize user-provided "named aggregation" kwargs.
Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
to the old Dict[str, List[scalar]]].

Parameters
----------
kwargs : dict

Returns
-------
aggspec : dict
    The transformed kwargs.
columns : tuple[str, ...]
    The user-provided keys.
col_idx_order : List[int]
    List of columns indices.

Examples
--------
>>> normalize_keyword_aggregation({"output": ("input", "sum")})
(defaultdict(<class 'list'>, {'input': ['sum']}), ('output',), array([0]))
r   r   )pandas.core.indexes.baser-   r   ry   r   r   r   rn   rz   _make_unique_kwarg_listget_indexer)r;   r-   aggspecrG  r   pairscolumnaggfuncuniquified_orderaggfuncsaggspec_orderuniquified_aggspeccol_idx_orders                rE   rE  rE    s    < /
 $GE#v||~./NG w'fc33G<GHI !
 /u5 !( /FG 
&&w/:7; 	< /  
 1? ,-99:JKM]**s   &7Dc           
         [        U 5       VVs/ s H=  u  pU R                  U5      S:  a!  US   US    SU SU R                  U5       34OUPM?     snn$ s  snnf )z
Uniquify aggfunc name of the pairs in the order list

Examples:
--------
>>> kwarg_list = [('a', '<lambda>'), ('a', '<lambda>'), ('b', '<lambda>')]
>>> _make_unique_kwarg_list(kwarg_list)
[('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
r4   r   rD   N)r   count)seqr  pairs      rE   rM  rM    sl     !~%GA :=419LaT!WIQs2Aw}}T2345RVV%  s   AAc                   SSK Jn  [        [        X#5      S S9 Vs/ s H  oUS   PM	     nn0 nSn[	        U [
        5      (       + =(       a    [        U R                  5      S:  n	UR                  5        H  u  pX
   R                  5       nU	(       am  U Vs/ s H0  n[	        U[        5      (       d  [        R                  " U5      OUPM2     nnU" UR                  5      R                  U5      nUR                  U   nXhU[        U5      -    Ul        UR!                  USS9Xz'   U[        U5      -   nM     U$ s  snf s  snf )aR  
Internal function to reorder result if relabelling is True for
dataframe.agg, and return the reordered result in dict.

Parameters:
----------
result: Result from aggregation
func: Dict of (column name, funcs)
columns: New columns name for relabelling
order: New order for relabelling

Examples
--------
>>> from pandas.core.apply import relabel_result
>>> result = pd.DataFrame(
...     {"A": [np.nan, 2, np.nan], "C": [6, np.nan, np.nan], "B": [np.nan, 4, 2.5]},
...     index=["max", "mean", "min"]
... )
>>> funcs = {"A": ["max"], "C": ["max"], "B": ["mean", "min"]}
>>> columns = ("foo", "aab", "bar", "dat")
>>> order = [0, 1, 2, 3]
>>> result_in_dict = relabel_result(result, funcs, columns, order)
>>> pd.DataFrame(result_in_dict, index=columns)
       A    C    B
foo  2.0  NaN  NaN
aab  NaN  6.0  NaN
bar  NaN  NaN  4.0
dat  NaN  NaN  2.5
r   r   c                    U S   $ )Nr4   rP   )ts    rE   <lambda> relabel_result.<locals>.<lambda>?  s    adrG   )r   r4   Fr  )rL  r-   sortedr   rh   r$   r   r   r   dropnari   rn   rz   r   rN  r   reindex)r   rA   r   rG  r-   r[  reordered_indexesreordered_result_in_dictidxreorder_maskr   funsrr   rW  s                  rE   relabel_resultrj    s:   F / #3w#6NKKDQK   8:
C!&)44PV^^9Lq9PLJJLK , SVSVa
1c0B0B%%a(ISV   "!''N66s;M}%A $#C.9()		'	(F %CHnE !F $#U>s   D;7E c                v    SSK Jn  [        U40 UD6u  pApVU(       a  Uc   eUc   e[        XXV5      nU" XuS9n U $ )Nr   )r,   rp  )r   r,   r?   rj  )r   rA   r;   r,   rF  r   rG  result_in_dicts           rE   r   r   k  sQ     '7'G'G$Jg """   'gE>9MrG   c                    [        U 5      S::  a  U $ Sn/ nU  HI  n[        R                  " U5      S:X  a  [        U5      nSU S3Ul        US-  nUR                  U5        MK     U$ )a  
Possibly mangle a list of aggfuncs.

Parameters
----------
aggfuncs : Sequence

Returns
-------
mangled: list-like
    A new AggSpec sequence, where lambdas have been converted
    to have unique names.

Notes
-----
If just one aggfunc is passed, the name will not be mangled.
r4   r   z<lambda>z<lambda_>)r   rn   rz   r   r  r   )rT  r  mangled_aggfuncsrR  s       rE   _managle_lambda_listrp    sv    $ 8}	A  )Z7g&G!)!AGFA(  rG   c                ,   [        U 5      nU(       d  [        U 5      (       d  U $ [        U 5      " 5       nU(       aM  U R                  5        H7  u  p4[        U5      (       a  [        U5      (       d  [	        U5      nOUnXRU'   M9     U$ [	        U 5      nU$ )a
  
Make new lambdas with unique names.

Parameters
----------
agg_spec : Any
    An argument to GroupBy.agg.
    Non-dict-like `agg_spec` are pass through as is.
    For dict-like `agg_spec` a new spec is returned
    with name-mangled lambdas.

Returns
-------
mangled : Any
    Same type as the input.

Examples
--------
>>> maybe_mangle_lambdas('sum')
'sum'
>>> maybe_mangle_lambdas([lambda: 1, lambda: 2])  # doctest: +SKIP
[<function __main__.<lambda_0>,
 <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
)r   r   r  r   rp  )agg_specis_dictmangled_aggspecr   rT  ro  s         rE   maybe_mangle_lambdasru    s    2 8$G|H--8n&O%^^-MCH%%l8.D.D#7#A #+ #3C  .  /x8rG   c                B   Sn[        U 5      n/ nU R                  5        Hf  n[        U[        5      (       d=  [	        U5      (       d-  [        UR                  [        U5      R                  5      5      eUR                  U5        Mh     U(       d  Sn[        U5      eX#4$ )a  
Validates types of user-provided "named aggregation" kwargs.
`TypeError` is raised if aggfunc is not `str` or callable.

Parameters
----------
kwargs : dict

Returns
-------
columns : List[str]
    List of user-provided keys.
func : List[Union[str, callable[...,Any]]]
    List of user-provided aggfuncs

Examples
--------
>>> validate_func_kwargs({'one': 'min', 'two': 'max'})
(['one', 'two'], ['min', 'max'])
z-func is expected but received {} in **kwargs.z2Must provide 'func' or named aggregation **kwargs.)
ry   rZ  rh   ri   rm   r}   formatr  r  r   )r;   tuple_given_messager   rA   col_funcno_arg_messages         rE   validate_func_kwargsr{    s    . J6lGDMMO8S))Xh-?-?/66tH~7N7NOPPH $ M''=rG   c                h    [        U[        5      =(       d    [        U[        5      =(       a    U S:H  $ )Nrs   )rh   r"   r$   )r`   r   s     rE   r   r     s*    dL) 4#85(8rG   c           	         UR                  S5      (       a  UnO [        U 5      R                   SU 3nSU S3n[        R                  " SU SU SU S3[
        [        5       S9  g )	Nznp.."zThe provided callable z is currently using zw. In a future version of pandas, the provided callable will be used directly. To keep current behavior pass the string z	 instead.)categoryr  )
startswithr  r  r  r  r  r   )r@   rA   alias
full_aliass       rE   rp   rp     sy    
 
S	**+1UG4
E7!MM
 &:, $$)7)	5 #%rG   )r   FNrK   rL   NNN)r@   r,   rA   r   rB   r   r5   r
  r6   r  r7   r  r8   ri   r9   r  r  r2   )rA   zAggFuncType | Noner  zMtuple[bool, AggFuncType, tuple[str, ...] | None, npt.NDArray[np.intp] | None])r  r
  )r;   r   r  z]tuple[MutableMapping[Hashable, list[AggFuncTypeBase]], tuple[str, ...], npt.NDArray[np.intp]])rZ  Sequence[tuple[Any, Any]]r  r  )
r   r  rA   zdict[str, list[Callable | str]]r   r  rG  zIterable[int]r  zdict[Hashable, Series]r  )rT  Sequence[Any]r  r  )rr  r   r  r   )r;   r   r  z0tuple[list[str], list[str | Callable[..., Any]]])r`   r  r   r  r  r
  )r@   r   rA   r   r  ri   r  r  )g
__future__r   r  collectionsr   r  r   r   typingr   r   r   r	   r
   r  numpyr  pandas._configr   pandas._libsr   pandas._libs.internalsr   pandas._typingr   r   r   r   r   r   r   r   pandas.compat._optionalr   pandas.errorsr   pandas.util._decoratorsr   pandas.util._exceptionsr   pandas.core.dtypes.castr   pandas.core.dtypes.commonr   r   r   r   r   pandas.core.dtypes.dtypesr    r!   pandas.core.dtypes.genericr"   r#   r$   pandas.core._numba.executorr%   pandas.core.commoncorecommonrn   pandas.core.constructionr&   collections.abcr'   r(   r)   r*   r+   r   r,   r-   r.   pandas.core.groupbyr/   pandas.core.resampler0   pandas.core.window.rollingr1   r   intr  rF   ABCMetarI   r   r2   r=   r>   r)  r#  r:  r?   rC  rE  rM  rj  r   rp  ru  r{  r   rp   rP   rG   rE   <module>r     sq   " 
 #       )  2	 	 	 ? , 2 4 4   >     C  
 ,.5 sCx. "'/,0	!	!
! ! 
	!
 ! %! ! *! !HL	&ckk L	&^:5 :zi# i#XgJ gTAz AHR, Rj[5 [|"< "8B,
B,RB,J4:+:+:+z	"$O$O$
)O$  O$ 	O$
 O$d6B)X!!5!H	
  
	rG   