
    n[we                       d dl mZ d dlZd dlmZ d dlmZ d dlZd dlm	Z	m
Z
mZmZmZmZ d dlZd dlZd dlmZ d dlmZ d dlmZmZmZmZmZmZmZmZ d d	lm Z  d d
l!m"Z" d dl#m$Z$ d dl%m&Z& d dl'm(Z(m)Z)m*Z* d dl+m,Z,m-Z- d dl.m/Z/m0Z0m1Z1 d dl2m3c m4Z5 d dl6m7Z7 e	r(d dl8m9Z9m:Z:m;Z;m<Z< d dl=m>Z>m?Z?m@Z@ d dlAmBZB d dlCmDZD d dlEmFZF eGeHe
f         ZI	 	 	 	 	 	 d_d`d&ZJ G d' d(ejK        )          ZL G d* d+eL          ZM G d, d%eM          ZN G d- d.eN          ZO G d/ d0eN          ZP G d1 d2eM          ZQ G d3 d4eL          ZR G d5 d6eR          ZSdad9ZTdbd:ZUdcd>ZVdddAZWdedJZXdfdKZYdgdNZZdhdQZ[didSZ\djdXZ]dkd^Z^dS )l    )annotationsN)defaultdict)partial)TYPE_CHECKINGAnyCallableDefaultDictLiteralcast)option_context)lib)AggFuncTypeAggFuncTypeBaseAggFuncTypeDict
AggObjTypeAxisAxisIntNDFrameTnpt)SpecificationError)cache_readonly)find_stack_level)is_nested_object)is_dict_likeis_list_likeis_sequence)CategoricalDtypeExtensionDtype)ABCDataFrame
ABCNDFrame	ABCSeries)ensure_wrapped_if_datetimelike)HashableIterableIteratorSequence)	DataFrameIndexSeries)GroupBy)	Resampler)
BaseWindowFcompatobjr'   funcr   axisr   rawboolresult_type
str | Noneby_rowLiteral[False, 'compat']return
FrameApplyc           	         |                      |          }|dk    rt          }n|dk    rt          }t          |fi |\  }	}}	}	|J  || ||||||          S )z=construct and return a row or column based frame apply objectr      Nr1   r3   r5   argskwargs)_get_axis_numberFrameRowApplyFrameColumnApplyreconstruct_func)
r.   r/   r0   r1   r3   r5   r<   r=   klass_s
             1lib/python3.11/site-packages/pandas/core/apply.pyframe_applyrE   L   s     %%Dqyy	 $T44V44MAtQ5       c                      e Zd ZU ded<   ddd9dZej        d:d            Zej        d;d            Zej        d;d            Z	d<dZ
d:dZd Zd:dZd:dZd=d#Zd>d(Zd:d)Zd?d,Zd@d0Zd:d1Zd:d2ZdAd6ZdBd7Zd8S )CApplyr   r0   r-   r5   r.   r   r/   r   r1   r2   r3   r4   r5   #Literal[False, 'compat', '_compat']r7   Nonec                   || _         || _        |du s|dv sJ || _        |pd| _        |pi | _        |dvrt          d          || _        || _        d S )NF)r-   _compat )Nreduce	broadcastexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'})r.   r1   r5   r<   r=   
ValueErrorr3   r/   )selfr.   r/   r1   r3   r5   r<   r=   s           rD   __init__zApply.__init__o   s     &,A"A"A"A"AJB	lEEE=  
 '			rF   DataFrame | Seriesc                    d S NrN   rS   s    rD   applyzApply.apply   s    rF   op_nameLiteral['agg', 'apply']c                    d S rW   rN   rS   rZ   s     rD   agg_or_apply_list_likezApply.agg_or_apply_list_like   	     	rF   c                    d S rW   rN   r]   s     rD   agg_or_apply_dict_likezApply.agg_or_apply_dict_like   r_   rF   DataFrame | Series | Nonec                   | j         }| j        }| j        }| j        }t	          |t
                    r|                                 S t          |          r|                                 S t          |          r| 
                                S t          |          rCt          j        |          }|r-|s+|s)t          |||            t          ||                      S dS )z
        Provide an implementation for the aggregators.

        Returns
        -------
        Result of aggregation, or None if agg cannot be performed by
        this method.
        N)r.   r/   r<   r=   
isinstancestr	apply_strr   agg_dict_liker   agg_list_likecallablecomget_cython_funcwarn_alias_replacementgetattr)rS   r.   r/   r<   r=   fs         rD   aggz	Apply.agg   s     hyydC   	$>>### 	(%%'''$ 	(%%'''D>> 	)#D))A ) )f )&sD!444&wsA((( trF   c                   | j         }| j        | j        }| j        }| j        }|j        dk    }|                    |          dk    r |rJ  |j        j        dg|R i |j        S t                    rLt                    s=t          t          t                             |rd D             nfd|D             t                    r*t          t                    |                               S t          t                    	 |                               }n,# t"          $ r  t$          $ r}t'          d          |d}~ww xY wt)          |t*          t,          f          r|j        r|j        st'          d          t)          |t*          t,          f          r|j                            |j                  st'          d          |S )aI  
        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.
        r:   r   c                <    i | ]}t          j        |          p||S rN   rj   get_callable_name.0vs     rD   
<dictcomp>z#Apply.transform.<locals>.<dictcomp>   s*    GGGQ-a005AqGGGrF   c                    i | ]}|S rN   rN   )ru   colr/   s     rD   rw   z#Apply.transform.<locals>.<dictcomp>   s    111cT111rF   zTransform function failedNzFunction did not transform)r.   r/   r0   r<   r=   ndimr>   T	transformr   r   r   listr   r   transform_dict_liketransform_str_or_callable	TypeError	ExceptionrR   rd   r!   r   emptyindexequals)	rS   r.   r0   r<   r=   	is_seriesresulterrr/   s	           @rD   r|   zApply.transform   s!    hyyyHM	%%**    "35?4<T<<<V<<>> 	2l4&8&8 	2_-t44D 2GG$GGG1111S111 	2..D++D111 OT**	C33D99FF 	 	 	 	C 	C 	C899sB	C v	<899	:	: I	:
 8999
 &9l";<< 	;FLDWDWIE
 E
 	; 9:::s   D) )E=EEc                   ddl m} | j        }| j        }| j        }t          |t                    sJ t          |          dk    rt          d          | 	                    d||          }i }|
                                D ]1\  }}|                    |d          }	 |	j        |dg|R i |||<   2 ||d          S )zC
        Compute transform in the case of a dict-like func
        r   concatz$No transform functions were providedr|   r:   rz   r0   )pandas.core.reshape.concatr   r.   r<   r=   rd   r    lenrR   normalize_dictlike_argitems_gotitemr|   )
rS   r/   r   r.   r<   r=   resultsnamehowcolgs
             rD   r~   zApply.transform_dict_like   s     	655555hy #z*****t99>>CDDD**;TBB68 	D 	DID#<<1<--D*DN3CDCCCFCCGDMMvgA&&&&rF   c                Z   | j         }| j        }| j        }t          |t                    r | j        ||g|R i |S |sA|s?t          j        |          }|r)t          |||            t          ||                      S 	  |j
        |fd|i|S # t          $ r  ||g|R i |cY S w xY w)zL
        Compute transform in the case of a string or callable func
        r<   )r.   r<   r=   rd   re   
_apply_strrj   rk   rl   rm   rY   r   )rS   r/   r.   r<   r=   rn   s         rD   r   zApply.transform_str_or_callable  s    hydC   	?"4?3>t>>>v>>> 	)F 	)#D))A )&sD!444&wsA(((	.39T777777 	. 	. 	.4-d---f-----	.s   B B*)B*c                .    |                      d          S )z
        Compute aggregation in the case of a list-like argument.

        Returns
        -------
        Result of aggregation.
        ro   rZ   )r^   rX   s    rD   rh   zApply.agg_list_like/       **5*999rF   selected_objSeries | DataFramer=   dict[str, Any] tuple[list[Hashable], list[Any]]c                J   t          t          t                   | j                  }| j        }g }g }|j        dk    r|D ]}|                    |j        d|          }	t          ||	          r| j	        g| j
        n| j
        }
 t          |	|          |g|
R i |}|                    |           t          j        |          p|}|                    |           ng }t          |          D ]\  }}|                    |d|j        dd|f                   }	t          ||	          r| j	        g| j
        n| j
        }
 t          |	|          |g|
R i |}|                    |           |                    |           |j                            |          }||fS )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]
            Index labels for result.
        results : list
            Data for result. When aggregating with a Series, this can contain any
            Python objects.
        r:   )rz   subsetN)r   r}   r   r/   r.   rz   r   r   include_axisr0   r<   rm   appendrj   rs   	enumerateiloccolumnstake)rS   rZ   r   r=   r/   r.   r   keysar   r<   new_resr   indicesr   ry   s                   rD   compute_list_likezApply.compute_list_like9  s   4 D)4955h !! " "||L$5Al|SS $GT22#TY+++ 
 1'$00DTDDDVDDw''' ,Q//41D!!!!" G'55 	& 	&
s||Ca8I!!!U(8S|TT $GT22#TY+++ 
 1'$00GGGGGGw'''u%%%%',,W55DW}rF   r   list[Hashable]r   list[Series | DataFrame]c                    ddl m} | j        }	  |||dd          S # t          $ rD}ddlm}  ||||j                  }t          |          rt          d          ||cY d }~S d }~ww xY w)	Nr   r   r:   F)r   r0   sortr)   r   r   z3cannot combine transform and aggregation operations)	r   r   r.   r   pandasr)   r   r   rR   )rS   r   r   r   r.   r   r)   r   s           rD   wrap_results_list_likezApply.wrap_results_list_likey  s     	655555h	6'15AAAA 
	 
	 
	 &%%%%%VG4ch???F''  I  MMMMMM
	s    
A,9A'!A,'A,c                .    |                      d          S )z
        Compute aggregation in the case of a dict-like argument.

        Returns
        -------
        Result of aggregation.
        ro   r   )ra   rX   s    rD   rg   zApply.agg_dict_like  r   rF   	selectionHashable | Sequence[Hashable]c                8   ddl m}m} | j        t	          ||f          }t          t          | j                  }|                     |          }j	        dk    o.j
                                        t          j
                  k     }	j	        dk    r\                    |d          fd|                                D             }
t          |                                          }n|s|	rg }
g }|                                D ]\  }j
                            |g          }j
                            |          }t'          t                    }t)          ||          D ] \  }}||                             |           !fd|                                D             }||gt          |          z  z  }|
|z  }
nCfd|                                D             }
t          |                                          }||
fS )	a  
        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   r:   r   c                D    g | ]\  }} t                    |fi S rN   )rm   )ru   rC   r   r   r=   rZ   s      rD   
<listcomp>z+Apply.compute_dict_like.<locals>.<listcomp>  s:    XXXC-wtW--c<<V<<XXXrF   c           
     x    g | ]6\  }}|D ].} t                              |d                     fi /7S )r:   r   )rm   _ixs)ru   labelr   indicer   r=   rZ   r   s       rD   r   z+Apply.compute_dict_like.<locals>.<listcomp>  st       &w")   HGL--f1-==wGGVVvVV   rF   c           	     n    g | ]1\  }} t                              |d                     |fi 2S )r:   r   )rm   r   )ru   keyr   r=   r.   rZ   s      rD   r   z+Apply.compute_dict_like.<locals>.<listcomp>  sY       C <Sq117;;CJJ6JJ  rF   )pandas.core.groupby.genericr   r   r.   rd   r   r   r/   r   rz   r   nuniquer   r   r   r}   r   get_indexer_forr   r   zipr   )rS   rZ   r   r   r=   r   r   
is_groupbyr/   is_non_unique_colr   r   r   r   labelslabel_to_indicesr   r   key_datar   r   r.   s    `` `              @@@rD   compute_dict_likezApply.compute_dict_like  s   :	
 	
 	
 	
 	
 	
 	
 	

 h&6%FGG
OTY//**7L$GG " K$,,..\5I1J1JJ 	
 !!<<	<22DXXXXXX4::<<XXXG		$$DD 	% 1 	% GD JJLL $ $S&.>>uEE%-227;;#.t#4#4 $'$8$8 : :LE5$U+2259999      *:*@*@*B*B   H--8#$"      $

  G 		$$DW}rF   result_indexresult_datar}   c                R   ddl m} ddlm} | j        }d |D             }t          |          rt          t          ||                    fd|D             }|g k    r|n|}|j        dk    r, ||          }	|		                    |j
        j                   |	}t          |t                    rdnd}
 |fd|D             |
|	          }nWt          |          rt          d
          ddl m} |j        dk    rt#          d|          }|j        }nd } ||||          }|S )Nr   r(   r   c                8    g | ]}t          |t                    S rN   )rd   r    )ru   rs     rD   r   z0Apply.wrap_results_dict_like.<locals>.<listcomp>  s"    EEEAjJ//EEErF   c                .    g | ]}|         j         |S rN   )r   ru   kr   s     rD   r   z0Apply.wrap_results_dict_like.<locals>.<listcomp>  s%    KKK'!*:JK1KKKrF   r   r:   c                "    i | ]}||         S rN   rN   r   s     rD   rw   z0Apply.wrap_results_dict_like.<locals>.<dictcomp>  s    4441GAJ444rF   )r0   r   zLcannot perform both aggregation and transformation operations simultaneouslyr   r)   r   )r   r(   r   r   r.   alldictr   rz   
_set_namesr   namesrd   r!   anyrR   r)   r   r   )rS   r   r   r   r(   r   r.   
is_ndframekeys_to_usektur0   r   r)   r   r   s                 @rD   wrap_results_dict_likezApply.wrap_results_dict_like  s    	!     555555h FEEEE
z?? $	H3|[99::GKKKKlKKKK)4):):++K A%%eK((|39:::!!+C!;!;BAADV4444444   FF
 __ 	H!   &%%%%% x1}}8S))xVK|$GGGFrF   c                   t          t          | j                  }| j        }ddlm}m} t          ||d          }t          |          rt          j
        |          }g |j        |j        R }| j        dk    rd|vs|dv rt          d| d          d|v rNt          |||f          r-d}|dv r| j        j        }|| j        k    r| j        | j        d<   n| j        | j        d<    | j        ||g| j        R i | j        S )	zy
        Compute apply in case of a string.

        Returns
        -------
        result: Series or DataFrame
        r   r   Nr0   )corrwithskewz
Operation z does not support axis=1)idxmaxidxmin)r   re   r/   r.   r   r   r   rm   ri   inspectgetfullargspecr<   
kwonlyargsr0   rR   rd   r=   r   )	rS   r/   r.   r   r   methodsig	arg_namesdefault_axiss	            rD   rf   zApply.apply_str  s[    C##h	
 	
 	
 	
 	
 	
 	
 	
 dD))F 	4(00C4#(4S^44IyA~~i''43G+G+G !Ld!L!L!LMMM""cM3C#DEE 4
 $%L333 (,x}#ty00.2iF+*.)DK'tsDD49DDDDDDrF   c                ^   | j         dk    rIt          | j        t                    r/ | j        j        j        | j        dfd| j        i| j        j        S | j        }| j        }t          |          r| 
                    d          }n|                     d          }t          ||fi |}|S )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.
        r:   r   r<   rY   r   )r0   rd   r.   r   r{   rY   r/   r<   r=   r   ra   r^   reconstruct_and_relabel_result)rS   r/   r=   r   s       rD   apply_list_or_dict_likezApply.apply_list_or_dict_likeL  s     9>>j<@@>#48:#DIqPPtyPDKPPRRy 	B000AAFF000AAF/GGGGrF   r   re   r   c                  	 |dv sJ |dk    r@t          |t                    r+t          d |                                D                       s+t          d |                                D                       rt	          d          |j        dk    r}ddlm}  |t          |	                                                    
                    |j        d	
          }t          |          dk    r t          dt          |           d          t          t          t          f	t          	fd|                                D                       r:i }|                                D ]!\  }}t          |	          s|g||<   |||<   "|}|S )a  
        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.
        )rY   ro   r|   ro   c              3  :   K   | ]\  }}t          |          V  d S rW   )r   ru   rC   rv   s      rD   	<genexpr>z/Apply.normalize_dictlike_arg.<locals>.<genexpr>t  s,      ==1LOO======rF   c              3  :   K   | ]\  }}t          |          V  d S rW   )r   r   s      rD   r   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>u  s,      ;;da,q//;;;;;;rF   znested renamer is not supportedr:   r   r   T)r   z
Column(s) z do not existc              3  >   K   | ]\  }}t          |          V  d S rW   )rd   )ru   rC   xaggregator_typess      rD   r   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>  s2      HH41az!-..HHHHHHrF   )rd   r!   r   r   r   rz   r   r(   r}   r   
differencer   r   KeyErrortupler   )
rS   r   r.   r/   r(   colsnew_funcr   rv   r   s
            @rD   r   zApply.normalize_dictlike_argd  s    33333 5LL3	** ==

=====  ;;djjll;;;;; 
 %%FGGG8q==$$$$$$5diikk**++66s{6NND4yy1}}EDJJEEEFFF %. HHHH4::<<HHHHH 	(*H

 $ $1!!%566 $#$#HQKK"#HQKKDrF   c                   t          |t                    sJ t          ||          r]t          ||          }t	          |          r ||i |S t          |          dk    sJ t          d |D                       dk    sJ |S t          t          |          r1t          |d          r!t          t          |          } ||g|R i |S d| dt          |          j         d}t          |          )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   c                    g | ]}|d v|	S )r   rN   )ru   kwargs     rD   r   z$Apply._apply_str.<locals>.<listcomp>  s"    KKK%U(5J5J5J5J5JrF   	__array__'z' is not a valid function for 'z' object)
rd   re   hasattrrm   ri   r   nptype__name__AttributeError)rS   r.   r/   r<   r=   rn   msgs          rD   r   zApply._apply_str  s"    $$$$$$3 	&T""A{{ *q$)&))) t99>>>>KK6KKKLLPQQQQQHR 	&73#<#< 	&D!!A1S*4***6***WdWW499;MWWWC %%%rF   N)r.   r   r/   r   r1   r2   r3   r4   r5   rJ   r7   rK   r7   rU   rZ   r[   r7   rU   )r7   rb   )rZ   r[   r   r   r=   r   r7   r   )r   r   r   r   )
rZ   r[   r   r   r   r   r=   r   r7   r   )r   r   r   r   r   r}   )r   re   r.   rU   r/   r   r7   r   )r/   re   )r  
__module____qualname____annotations__rT   abcabstractmethodrY   r^   ra   ro   r|   r~   r   rh   r   r   rg   r   r   rf   r   r   r   rN   rF   rD   rH   rH   l   s        MMM 7?     < 	    	   
 	   
   @A A A AF' ' '0. . . ..: : : :> > > >@   *: : : :M M M M^4 4 4 4l-E -E -E -E^   0+ + + +Z& & & & & &rF   rH   )	metaclassc                  ^    e Zd ZU dZded<   edd            Zedd            Zdd
ZddZ	dS )NDFrameApplyzg
    Methods shared by FrameApply and SeriesApply but
    not GroupByApply or ResamplerWindowApply
    rU   r.   r7   r(   c                    | j         j        S rW   )r.   r   rX   s    rD   r   zNDFrameApply.index  s    x~rF   c                @    | j                             | j                  S rW   )r.   _get_agg_axisr0   rX   s    rD   agg_axiszNDFrameApply.agg_axis  s    x%%di000rF   rZ   r[   c                f   | j         }| j        }|dk    rHt          | t                    r| j        }n#t          | t
                    r| j        rdnd}nd}i |d|i}t          |dd          dk    rt          d          |                     |||          \  }}| 	                    ||          }|S )	NrY   rM   Fr5   r0   r   r:   "axis other than 0 is not supported)
r.   r=   rd   r8   r5   SeriesApplyrm   NotImplementedErrorr   r   )rS   rZ   r.   r=   r5   r   r   r   s           rD   r^   z#NDFrameApply.agg_or_apply_list_like  s     hg$
++ D+.. &*k<u11&11F3""a''%&JKKK..wVDDg,,T7;;rF   c                $   |dv sJ | j         }i }|dk    r"| j        rdnd}|                    d|i           t          |dd          dk    rt	          d	          d }|                     ||||          \  }}|                     |||          }|S )
Nro   rY   rY   rM   Fr5   r0   r   r:   r  )r.   r5   updaterm   r  r   r   )	rS   rZ   r.   r=   r5   r   r   r   r   s	            rD   ra   z#NDFrameApply.agg_or_apply_dict_like  s     *****hg"&+8YY5FMM8V,---3""a''%&JKKK	$($:$:S)V%
 %
!k ,,S,LLrF   Nr7   r(   r	  )
r  r
  r  __doc__r  propertyr   r  r^   ra   rN   rF   rD   r  r    s          
    X 1 1 1 X1   .     rF   r  c                  x    e Zd ZU ded<   ddd) fdZeej        d*d                        Zeej        d*d                        Z	eej        d+d                        Z
ej        d,d            Zed*d            Zed*d            Zed             Zd-dZ fdZd  Zd! Zd.d#Zd$ Zd/d&Zd,d'Zd- fd(Z xZS )0r8   r'   r.   FrI   r   r/   r   r1   r2   r3   r4   r5   r6   r7   rK   c          	         |dur|dk    rt          d| d          t                                          |||||||           d S )NFr-   zby_row=z not allowed)r5   r<   r=   )rR   superrT   )	rS   r.   r/   r1   r3   r5   r<   r=   	__class__s	           rD   rT   zFrameApply.__init__  sn     6X#5#5;v;;;<<<sKT& 	 	
 	
 	
 	
 	
rF   r(   c                    d S rW   rN   rX   s    rD   r   zFrameApply.result_index  	     	rF   c                    d S rW   rN   rX   s    rD   result_columnszFrameApply.result_columns  r%  rF   Iterator[Series]c                    d S rW   rN   rX   s    rD   series_generatorzFrameApply.series_generator  r%  rF   r   ResType	res_indexrU   c                    d S rW   rN   rS   r   r,  s      rD   wrap_results_for_axisz FrameApply.wrap_results_for_axis  r_   rF   c                    | j         S rW   )r'  rX   s    rD   res_columnszFrameApply.res_columns  s    ""rF   c                    | j         j        S rW   )r.   r   rX   s    rD   r   zFrameApply.columns  s    xrF   c                    | j         j        S rW   )r.   valuesrX   s    rD   r4  zFrameApply.values   s    xrF   c                ^   t          | j                  r|                                 S t          | j                  dk    r,t          | j                  dk    r|                                 S t          | j        t                    r| 	                                S t          | j        t          j                  rtt          j        d          5  | j        j                            d| j                  }ddd           n# 1 swxY w Y   | j                            ||j                  S | j        dk    r|                     | j                  S t)          | j        j                  s|                                 S | j        r|                                 S |                                 S )	zcompute the resultsr   ignorer   rY   )r/   N)axesrP   )r   r/   r   r   r   r   apply_empty_resultrd   re   rf   r  ufuncerrstater.   _mgrrY   _constructor_from_mgrr8  r3   apply_broadcastr   shaper1   	apply_rawapply_standard)rS   r   s     rD   rY   zFrameApply.apply$  s    	"" 	2//111 t|!!c$*oo&:&:**,,, di%% 	N>>### 	28,, 	N*** G G(---gDI-FFG G G G G G G G G G G G G G G 811'1MMM {**''111 TX^$$ 	$**,,, X 	$>>###""$$$s   'DD	Dc                r   | j         }| j        }| j        dk    r| j         n| j         j        | _         d| _        d }	 t                                                      }|| _         || _        n# || _         || _        w xY w|dk    r||j        n|}|% | j         j        | j        |fd| j        i| j        }|S )Nr   r:   r<   )	r.   r0   r{   r"  ro   rY   r/   r<   r=   )rS   r.   r0   r   r#  s       rD   ro   zFrameApply.aggG  s    hy  $yA~~48848:		WW[[]]FDHDII DHDI199!'!3VXXF>#TX^DItSS$)St{SSFs    A, ,A<c                   t          | j                  sJ | j        dvr| j                                        S | j        dk    }ddlm} |s	 | j        dk    r1 | j         |g t          j	                  g| j
        R i | j        }n5 | j         || j        t          j	                  g| j
        R i | j        }t          ||           }n# t          $ r Y nw xY w|rrt          | j                  r1 | j         |g t          j	                  g| j
        R i | j        }nt          j        }| j                            || j                  S | j                                        S )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
        )rO   NrO   r   r   dtype)r   rE  r   )ri   r/   r3   r.   copyr   r)   r0   r  float64r<   r=   r   rd   r   r   r  nan_constructor_sliced)rS   should_reducer)   r   s       rD   r9  zFrameApply.apply_empty_result^  s    	""""" #3338==??" (H4!!!!!! 	::9>>!	r4447;y  DHK AA "	T\DDD   + A %/q&$9$9 9    
  	#4=!! DIffRrz:::VTYVVV$+VVF8///GGG8==??"s   A1C 
CCc                    d }t          j         || j                  | j        | j        g| j        R i | j        }|j        dk    r'| j        	                    || j
        | j                  S | j                            || j                  S )z$apply to the values as a numpy arrayc                      fd}|S )z
            Wrap user supplied function to work around numpy issue.

            see https://github.com/numpy/numpy/issues/8352
            c                 x     | i |}t          |t                    rt          j        |t                    }|S )NrD  )rd   re   r  arrayobject)r<   r=   r   r/   s      rD   wrapperz<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapper  sB    t.v..fc** <XfF;;;FrF   rN   )r/   rQ  s   ` rD   wrap_functionz+FrameApply.apply_raw.<locals>.wrap_function  s#         NrF   r   r   r   rF  )r  apply_along_axisr/   r0   r4  r<   r=   rz   r.   _constructorr   r   rJ  r  )rS   rR  r   s      rD   r@  zFrameApply.apply_raw  s    	 	 	 $M$)$$di
?Cy
 
 
LPK
 

 ;!8((tz4<(XXX8//dm/LLLrF   targetc                    t          | j                  sJ t          j        |j                  }|j        d         }t          |j                  D ]\  }} | j        ||         g| j        R i | j	        }t          j
        |          j        }|dk    rt          d          |dk    r"|t          |          k    rt          d          ||d d |f<   | j                            ||j        |j                  }|S )Nr   r:   ztoo many dims to broadcastzcannot broadcast resultrS  )ri   r/   r  
empty_liker4  r?  r   r   r<   r=   asarrayrz   rR   r   r.   rU  r   )	rS   rV  result_valuesresult_compareiry   resaresr   s	            rD   r>  zFrameApply.apply_broadcast  s   	"""""fm44  a// 	& 	&FAs$)F3KC$)CCCt{CCC:c??'D axx !=>>>qyy!SXX--$%>???"%M!!!Q$ &&v~ ' 
 
 rF   c                \    |                                  \  }}|                     ||          S rW   )apply_series_generatorwrap_resultsr.  s      rD   rA  zFrameApply.apply_standard  s0    !88::   )444rF   tuple[ResType, Index]c                   t          | j                  sJ | j        }| j        }i }t	          dd           5  t          |          D ]]\  }} | j        |g| j        R i | j        ||<   t          ||         t                    r||         
                    d          ||<   ^	 d d d            n# 1 swxY w Y   ||fS )Nzmode.chained_assignmentF)deep)ri   r/   r*  r   r   r   r<   r=   rd   r!   rG  )rS   
series_genr,  r   r\  rv   s         rD   r`  z!FrameApply.apply_series_generator  s   	"""""*
%	5t<< 	= 	=!*-- = =1&TYqD49DDDDD
gaj)44 = ")e!<!<GAJ=	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	!!s   A.B22B69B6c                0   ddl m} t          |          dk    r/d|v r+t          |d                   r|                     ||          S | j        j        }t          |          dk    r||u r ||t          j                  }n ||          }||_	        |S )Nr   r   rD  )
r   r)   r   r   r/  r.   rJ  r  rH  r   )rS   r   r,  r)   constructor_slicedr   s         rD   ra  zFrameApply.wrap_results  s    !!!!!! w<<!WWQZ1H1H--gyAAA "X9w<<1!3v!=!=''rzBBBFF''00F rF   c                    | j         dk    r5| j        }|j        | j                 }|                    || j                  S t                                                      S )NsizerF  )r/   r.   r?  r0   rJ  r  r"  rf   )rS   r.   valuer#  s      rD   rf   zFrameApply.apply_str  sX     9(CIdi(E**5*FFFww  """rF   )r.   r   r/   r   r1   r2   r3   r4   r5   r6   r7   rK   r  )r7   r(  r   r+  r,  r(   r7   rU   r  rV  r'   r7   r'   )r7   rb  )r  r
  r  r  rT   r  r  r  r   r'  r*  r/  r1  r   r   r4  rY   ro   r9  r@  r>  rA  r`  ra  rf   __classcell__r#  s   @rD   r8   r8     s        NNN ,1
 
 
 
 
 
 
 
(     X     X     X 	    # # # X#       X    ^!% !% !% !%F    .,# ,# ,#\M M M8   85 5 5" " " "&   *# # # # # # # # # #rF   c                  l    e Zd ZU dZded<   ed             Zedd            Zedd            ZddZ	dS )r?   r   r   r0   c                ^      fdt          t           j                            D             S )Nc              3  P   K   | ] }j                             |d           V  !dS )r:   r   N)r.   r   )ru   r\  rS   s     rD   r   z1FrameRowApply.series_generator.<locals>.<genexpr>  s5      KKQaa((KKKKKKrF   )ranger   r   rX   s   `rD   r*  zFrameRowApply.series_generator   s/    KKKK%DL8I8I2J2JKKKKrF   r7   r(   c                    | j         S rW   r   rX   s    rD   r   zFrameRowApply.result_index  
    |rF   c                    | j         S rW   rF  rX   s    rD   r'  zFrameRowApply.result_columns  
    zrF   r   r+  r,  rU   c                   | j         dk    r#| j                            |          }||_        |S | j         Nt	          d |                                D                       r#| j                            |          }||_        |S 	 | j                            |          }nL# t          $ r?}dt          |          v r(| j                            |          }||_        |cY d}~S  d}~ww xY wt          |d         t                    s6t          |j                  t          | j                  k    r| j        |_        t          |j                  t          |          k    r||_        |S )zreturn the results for the rowsrO   Nc              3  @   K   | ]}t          |t                    V  d S rW   )rd   r   )ru   r   s     rD   r   z6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>  s=       .
 .
$%Jq$.
 .
 .
 .
 .
 .
rF   dataz%All arrays must be of the same lengthr   )r3   r.   rJ  r   r   r4  rU  rR   re   rd   r!   r   r1  r   )rS   r   r,  r]  r   r   s         rD   r/  z#FrameRowApply.wrap_results_for_axis  s|   
 x''(..w77C!CIJ%# .
 .
)0)9)9.
 .
 .
 +
 +
%
 (..w77C!CIJ
	X***88FF 	 	 	6#c((BB h227;;%	





	 '!*i00 	06<  C(8$9$999#/v~#i..00&FNs$   B! !
C*+3C%C*$C%%C*Nr  rk  )
r  r
  r  r0   r  r  r*  r   r'  r/  rN   rF   rD   r?   r?     s         DL L XL    X    X' ' ' ' ' 'rF   r?   c                       e Zd ZU dZded<   d fdZed             Zedd
            Zedd            Z	ddZ
ddZ xZS )r@   r:   r   r0   rV  r'   r7   c                ^    t                                          |j                  }|j        S rW   )r"  r>  r{   )rS   rV  r   r#  s      rD   r>  z FrameColumnApply.apply_broadcast9  s#    ((22xrF   c              #  
  K   | j         }t          |          }t          |          dk    sJ | j                            dd          }|j        }t          |j        t                    rA| j        }t          t          |                    D ]}|                    |d          V  d S t          || j                  D ]A\  }}||_        |                    |           t                              |d|           |V  Bd S )Nr   r   _name)r4  r"   r   r.   r   r<  rd   rE  r   rr  r   r   
set_valuesrP  __setattr__)rS   r4  sermgrr.   r\  arrr   s           rD   r*  z!FrameColumnApply.series_generator=  s     /776{{Q hmmAAm&&hci00 	 (C3s88__ * *hhqqh))))))* * !44  	Ts###""3666				 rF   r(   c                    | j         S rW   rF  rX   s    rD   r   zFrameColumnApply.result_indexW  rw  rF   c                    | j         S rW   rt  rX   s    rD   r'  zFrameColumnApply.result_columns[  ru  rF   r   r+  r,  rU   c                    | j         dk    r|                     ||          }nSt          |d         t                    s"| j                            |          }||_        n|                     ||          }|S )z"return the results for the columnsrQ   r   )r3   infer_to_same_shaperd   r!   r.   rJ  r   rS   r   r,  r   s       rD   r/  z&FrameColumnApply.wrap_results_for_axis_  s|     x''--gyAAFF GAJ	22 	BX11'::F$FLL --gyAAFrF   c                    | j                             |          }|j        }||_        |                    d          }|S )z7infer the results to the same shape as the input objectrz  FrG  )r.   rU  r{   r   infer_objectsr  s       rD   r  z$FrameColumnApply.infer_to_same_shapet  sG    &&G&44 ! %%5%11rF   rl  r  rk  )r   r+  r,  r(   r7   r'   )r  r
  r  r0   r  r>  r  r*  r   r'  r/  r  rm  rn  s   @rD   r@   r@   6  s         D        X2    X    X   *       rF   r@   c                  ~     e Zd ZU ded<   dZded<   ded<   ej        dd	d fdZddZ fdZ	ddZ
d ZddZ xZS )r  r)   r.   r   r   r0   rJ   r5   r-   )convert_dtyper5   r/   r   r  bool | lib.NoDefaultr7   rK   c          	         |t           j        u rd}n(t          j        dt          t                                 || _        t                                          ||dd |||           d S )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``.
stacklevelFr;   )	r   
no_defaultwarningswarnFutureWarningr   r  r"  rT   )rS   r.   r/   r  r5   r<   r=   r#  s          rD   rT   zSeriesApply.__init__  s     CN** MMM? +--    + 	 	
 	
 	
 	
 	
rF   rU   c                p   | j         }t          |          dk    r|                                 S t          | j                  r|                                 S t          | j        t                    r|                                 S | j	        dk    r| 
                                S |                                 S )Nr   rM   )r.   r   r9  r   r/   r   rd   re   rf   r5   apply_compatrA  rS   r.   s     rD   rY   zSeriesApply.apply  s    hs88q==**,,, 	"" 	2//111di%% 	$>>###;)##$$&&& ""$$$rF   c                   t                                                      }|| j        }| j        }t	          |          sJ 	  |j        |fd| j        i| j        }d| dt          |          j	         dt          |          j	         d}t          j        |t          t                                 n3# t          t          t           f$ r  ||g| j        R i | j        }Y nw xY w|S )Nr<   zusing z in z3.agg cannot aggregate and has been deprecated. Use z&.transform to keep behavior unchanged.r  )r"  ro   r.   r/   ri   rY   r<   r=   r  r  r  r  r  r   rR   r  r   )rS   r   r.   r/   r  r#  s        rD   ro   zSeriesApply.agg  s   >(C9DD>>!!!

Q"4GGdiG4;GG
0T 0 0tCyy'9 0 004S		0B0 0 0 
 c==M=O=OPPPPP 	: > > >c=DI=====> s   B7 7-C'&C'c                |    | j         }|                    |j        |j                                      |d          S )N)rE  r   rY   r   )r.   rU  rE  r   __finalize__r  s     rD   r9  zSeriesApply.apply_empty_result  sC    hcisyAANN O 
 
 	
rF   c                P   | j         }| j        }t          |          r;t          j        |          }|r%| j        s| j        s|                    |d          S 	 |                    |d          }n4# t          t          t          f$ r |                    |d          }Y nw xY w|S )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
        FrI   r-   )r.   r/   ri   rj   rk   r<   r=   rY   rR   r  r   )rS   r.   r/   rn   r   s        rD   r  zSeriesApply.apply_compat  s     hyD>> 	5#D))A 5 54; 5yyey444	3YYtHY55FFNI6 	3 	3 	3YYtEY22FFF	3s   A2 2.B#"B#c                    t          t           j                   j        }t	          t
          j                  rDt          j        d          5   |g j        R i  j	        cd d d            S # 1 swxY w Y   n j
        s |g j        R i  j	        S  j        s j	        r fd}n}t	          |j        t                    rdnd }|                    || j                  }t          |          rDt	          |d         t                     r)|                    t%          |          |j                  S |                    ||j                                      |d          S )	Nr6  r7  c                0     | gj         R i j        S rW   )r<   r=   )r   r/   rS   s    rD   curriedz+SeriesApply.apply_standard.<locals>.curried  s'    tA9	999T[999rF   )mapper	na_actionconvertr   rF  rY   r  )r   r   r/   r.   rd   r  r:  r;  r<   r=   r5   rE  r   _map_valuesr  r   r!   _constructor_expanddimr}   r   rU  r  )rS   r.   r  actionmappedr/   s   `    @rD   rA  zSeriesApply.apply_standard  s   Hdi((hdBH%% 	8*** < <tC;$);;;t{;;< < < < < < < < < < < < < < < < < 	847di7774;7779 	 	: : : : : : : G (	3CDDN$fd6H ! 
 
 v;; 	:fQi;; 	 --d6ll#)-LLL##F#)#<<IIG J   s   A66A:=A:)
r.   r)   r/   r   r  r  r5   rJ   r7   rK   r  )r7   r)   )r  r
  r  r  r0   r   r  rT   rY   ro   r9  r  rA  rm  rn  s   @rD   r  r    s         KKKD//// /2n6>
 
 
 
 
 
 
 
@% % % %(    2
 
 
 
  ,$ $ $ $ $ $ $ $rF   r  c                  H     e Zd ZU ded<   d fdZd	 Zd
 ZddZddZ xZ	S )GroupByApplyz GroupBy | Resampler | BaseWindowr.   GroupBy[NDFrameT]r/   r   r7   rK   c                   |                                 }|j                            |                    dd                    | _        t                                          ||dd ||           d S )Nr0   r   Fr1   r3   r<   r=   )rG  r.   r>   getr0   r"  rT   rS   r.   r/   r<   r=   r#  s        rD   rT   zGroupByApply.__init__  st     G,,VZZ-B-BCC	 	 	
 	
 	
 	
 	
rF   c                    t           rW   r  rX   s    rD   rY   zGroupByApply.apply-      !!rF   c                    t           rW   r  rX   s    rD   r|   zGroupByApply.transform0  r  rF   rZ   r[   rU   c           	        | j         }| j        }|dk    ri |ddi}t          |dd          dk    rt          d          |j        j        dk    r|j        }n|j        }t          j        |dd	t          |d          
          5  | 
                    |||          \  }}d d d            n# 1 swxY w Y   |                     ||          }|S )NrY   r5   Fr0   r   r:   r  as_indexT	condition)r.   r=   rm   r  _selected_objrz   _obj_with_exclusionsrj   temp_setattrr  r   r   )rS   rZ   r.   r=   r   r   r   r   s           rD   r^   z#GroupByApply.agg_or_apply_list_like3  sF    hg00%00F3""a''%&JKKK!Q&&,LL3L TWS*-E-E
 
 
 	R 	R !227L&QQMD'	R 	R 	R 	R 	R 	R 	R 	R 	R 	R 	R 	R 	R 	R 	R ,,T7;;s   B--B14B1c           	        ddl m}m} |dv sJ | j        }i }|dk    r"| j        rdnd}|                    d|i           t          |dd          d	k    rt          d
          |j        }|j	        }t          |||f          }	|	rN| j                            dd           }
| j                            dd           }|                    |
|d           t          j        |ddt          |d                    5  |                     ||||          \  }}d d d            n# 1 swxY w Y   |                     |||          }|S )Nr   r   r  rY   rM   Fr5   r0   r:   r  engineengine_kwargs)r  r  r  Tr  )r   r   r   r.   r5   r  rm   r  r  
_selectionrd   r=   r  rj   r  r  r   r   )rS   rZ   r   r   r.   r=   r5   r   r   r   r  r  r   r   r   s                  rD   ra   z#GroupByApply.agg_or_apply_dict_likeM  s   	
 	
 	
 	
 	
 	
 	
 	

 *****hg"&+8YY5FMM8V,---3""a''%&JKKK(N	&6%FGG
  	N[__Xt44F KOOOTBBMMMVmLLMMMTWS*-E-E
 
 
 	 	 )-(>(>y&) )%L+	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ,,\<UUs   :D""D&)D&)r.   r  r/   r   r7   rK   r	  )
r  r
  r  r  rT   rY   r|   r^   ra   rm  rn  s   @rD   r  r    s         ))))
 
 
 
 
 
&" " "" " "   4% % % % % % % %rF   r  c                  F     e Zd ZU dZded<   ded<   d fd
Zd Zd Z xZS )ResamplerWindowApplyr   r   r0   Resampler | BaseWindowr.   r/   r   r7   rK   c               d    t          t          |                               ||dd ||           d S )NFr  )r"  r  rT   r  s        rD   rT   zResamplerWindowApply.__init__y  sH     	lD!!** 	+ 	
 	
 	
 	
 	
rF   c                    t           rW   r  rX   s    rD   rY   zResamplerWindowApply.apply  r  rF   c                    t           rW   r  rX   s    rD   r|   zResamplerWindowApply.transform  r  rF   )r.   r  r/   r   r7   rK   )	r  r
  r  r0   r  rT   rY   r|   rm  rn  s   @rD   r  r  u  sz         D
 
 
 
 
 
"" " "" " " " " " "rF   r  AggFuncType | NoneGtuple[bool, AggFuncType, list[str] | None, npt.NDArray[np.intp] | None]c                0   | du ot          di |}d}d}|sbt          | t                    r<t          |           t          t	          |                     k    rt          d          | t          d          |rt          |          \  } }}| J || ||fS )a  
    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: list 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).rN   )is_multi_agg_with_relabelrd   r}   r   setr   r   normalize_keyword_aggregation)r/   r=   
relabelingr   orders        rD   rA   rA     s    N E";"E"Ef"E"EJ $G)-E 
TdD!! 	c$ii#c$ii..&@&@ %   <RSSS E<VDDgutWe++rF   c                 ~    t          d |                                 D                       ot          |           dk    S )ax  
    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  f   K   | ],}t          |t                    ot          |          d k    V  -dS )r   N)rd   r   r   rt   s     rD   r   z,is_multi_agg_with_relabel.<locals>.<genexpr>  s;      MMz!U##3A!MMMMMMrF   r   )r   r4  r   )r=   s    rD   r  r    s=    * MMV]]__MMMMM FarF   r=   r   ,tuple[dict, list[str], npt.NDArray[np.intp]]c                   ddl m} t          t                    }g }t          t	          |                                            \  }}|D ]K\  }}||                             |           |                    |t          j        |          p|f           Lt          |          }d |                                D             }	t          |	          }
 ||
          
                    |          }|||fS )aL  
    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 : List[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   c                N    g | ]"\  }}|D ]}|t          j        |          p|f#S rN   rr   )ru   columnaggfuncsaggfuncs       rD   r   z1normalize_keyword_aggregation.<locals>.<listcomp>  sX       FH   
&w//:7;   rF   )pandas.core.indexes.baser(   r   r}   r   r   r   rj   rs   _make_unique_kwarg_listget_indexer)r=   r(   aggspecr  r   pairsr  r  uniquified_orderaggspec_orderuniquified_aggspeccol_idx_orders               rD   r  r    s   4 /..... 't,,GE#v||~~.//NGU  J Jw'''fc3G<<GHIIII /u55
  '  M
 1?? E,--99:JKKMG]**rF   seqSequence[tuple[Any, Any]]c                :      fdt                     D             S )a  
    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>')]
    c                    g | ]P\  }}                     |          d k    r0|d         |d           dd|                              |           fn|QS )r:   r   rC   N)count)ru   r\  pairr  s      rD   r   z+_make_unique_kwarg_list.<locals>.<listcomp>0  sv       At :=419L9LaT!W44s2A2w}}T224455RV  rF   )r   )r  s   `rD   r  r  $  s4        ~~   rF   r   rU   dict[str, list[Callable | str]]r   Iterable[Hashable]r  Iterable[int]dict[Hashable, Series]c                D   ddl m} d t          t          ||          d           D             }i }d}t	          | t
                     ot          | j                  dk    }|                                D ]\  }	}
| |	         	                                }|r<d |
D             }
 ||j
                                      |
          }|j        |         }|||t          |
          z            |_
        |                    |d	          ||	<   |t          |
          z   }|S )
a  
    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                    g | ]
}|d          S )r   rN   )ru   r  s     rD   r   z"relabel_result.<locals>.<listcomp>[  s)       Q  rF   c                    | d         S )Nr:   rN   )ts    rD   <lambda>z relabel_result.<locals>.<lambda>\  s
    ad rF   )r   r:   c                d    g | ]-}t          |t                    st          j        |          n|.S rN   )rd   re   rj   rs   )ru   rn   s     rD   r   z"relabel_result.<locals>.<listcomp>z  sD       NO
1c0B0BI%a(((  rF   Fr  )r  r(   sortedr   rd   r!   r   r   r   dropnar   r  r   reindex)r   r/   r   r  r(   reordered_indexesreordered_result_in_dictidxreorder_maskry   funsr  s                rD   relabel_resultr  6  sT   F /..... "3w#6#6NNKKK   8:
C!&)444PV^9L9Lq9PLJJLL " "S3K  ,  	& SV  C "E!'NN66s;;M}%A $C#C.$89()		'	(F(F %CHHn##rF   c                    ddl m} t          |fi |\  }}}}|r'|J |J t          | |||          } |||          } | S )Nr   )r'   rF  )r   r'   rA   r  )r   r/   r=   r'   r  r   r  result_in_dicts           rD   r   r     s          '7'G'G'G'G$Jgu 
: """   'guEE>999MrF   r  Sequence[Any]c                    t          |           dk    r| S d}g }| D ]N}t          j        |          dk    rt          |          }d| d|_        |dz  }|                    |           O|S )aJ  
    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.
    r:   r   z<lambda>z<lambda_>)r   rj   rs   r   r  r   )r  r\  mangled_aggfuncsr  s       rD   _managle_lambda_listr    s    $ 8}}	A ) ) ))Z77g&&G.!GFA((((rF   agg_specr   c                :   t          |           }|st          |           s| S  t          |                       }|rP|                                 D ]:\  }}t          |          rt          |          st	          |          }n|}|||<   ;nt	          |           }|S )aZ  
    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   r  )r  is_dictmangled_aggspecr   r  r  s         rD   maybe_mangle_lambdasr    s    2 8$$G |H-- $d8nn&&O 	9%^^-- 	4 	4MCH%% ,l8.D.D ,#7#A#A  #+ #3OC  	4 /x88rF   0tuple[list[str], list[str | Callable[..., Any]]]c                ^   d}t          |           }g }|                                 D ]o}t          |t                    sCt	          |          s4t          |                    t          |          j                            |	                    |           p|sd}t          |          ||fS )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.)
r}   r4  rd   re   ri   r   formatr  r  r   )r=   tuple_given_messager   r/   col_funcno_arg_messages         rD   validate_func_kwargsr
    s    . J6llGDMMOO  8S)) 	QXh-?-? 	Q/66tH~~7NOOPPPH (M'''D=rF   rZ   r[   r   r   c                b    t          |t                    pt          |t                    o| dk    S )Nro   )rd   r   r!   )rZ   r   s     rD   r   r     s0    dL)) 4##85(8rF   r   r   aliasre   rK   c           	         |                     d          r|}nt          |           j         d| }d| d}t          j        d| d| d| dt
          t                                 d S )	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.   r/   r  
full_aliass       rD   rl   rl     s    
  

S		*44U44
EM	5 	5 	5	5 	5 %*	5 	5 	5 #%%     rF   )r   FNr-   NN)r.   r'   r/   r   r0   r   r1   r2   r3   r4   r5   r6   r7   r8   )r/   r  r7   r  )r7   r2   )r=   r   r7   r  )r  r  r7   r  )
r   rU   r/   r  r   r  r  r  r7   r  r  )r  r  r7   r  )r  r   r7   r   )r=   r   r7   r  )rZ   r[   r   r   r7   r2   )r.   r   r/   r   r  re   r7   rK   )_
__future__r   r  collectionsr   	functoolsr   r   typingr   r   r   r	   r
   r   r  numpyr  pandas._configr   pandas._libsr   pandas._typingr   r   r   r   r   r   r   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._exceptionsr   pandas.core.dtypes.castr   pandas.core.dtypes.commonr   r   r   pandas.core.dtypes.dtypesr   r   pandas.core.dtypes.genericr   r    r!   pandas.core.commoncorecommonrj   pandas.core.constructionr"   collections.abcr#   r$   r%   r&   r   r'   r(   r)   pandas.core.groupbyr*   pandas.core.resampler+   pandas.core.window.rollingr,   r   intr+  rE   ABCMetarH   r  r8   r?   r@   r  r  r  rA   r  r  r  r  r   r  r  r
  r   rl   rN   rF   rD   <module>r,     s   " " " " " " 



 # # # # # #                            ) ) ) ) ) )      	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 - , , , , , 2 2 2 2 2 2 4 4 4 4 4 4 4 4 4 4 4 4         
                 !                 C C C C C C 6                    
 ,+++++......555555 sCx. "'/	    @~& ~& ~& ~& ~&ck ~& ~& ~& ~&B: : : : :5 : : :zP# P# P# P# P# P# P# P#f6 6 6 6 6J 6 6 6rI I I I Iz I I IXR R R R R, R R Rj[ [ [ [ [5 [ [ [|" " " " "< " " "8;, ;, ;, ;,|   48+ 8+ 8+ 8+v   $O$ O$ O$ O$d   6   B) ) ) )X! ! ! !H        rF   