
    bMhp                   *   d dl mZ d dlZd dlmZ d dlZd dlmZ d dlZd dl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 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) d dl*m+Z+m,Z,m-Z-m.Z.m/Z/ d dl0m1Z1m2Z2 d dl3m4Z4m5Z5m6Z6 d dl7m8Z8 d dl9m:c m;Z< d dl=m>Z> e	r*d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZGmHZH d dlImJZJ d dlKmLZL d dlMmNZN eOePe
f         ZQ	 	 	 	 	 	 	 	 dfdgd.ZR G d/ d0ejS        1          ZT G d2 d3eT          ZU G d4 d-eU          ZV G d5 d6eV          ZW G d7 d8eV          ZX G d9 d:eU          ZY G d; d<eT          ZZ G d= d>eZ          Z[dhdAZ\didBZ]djdFZ^dkdIZ_dldRZ`dmdSZadndVZbdodYZcdpd[Zddqd`ZedrdeZfdS )s    )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)
BaseWindowFcompatpythonobjr,   funcr   axisr   rawboolresult_type
str | Noneby_rowLiteral[False, 'compat']enginestrengine_kwargsdict[str, bool] | None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)r7   r9   r;   r=   r?   argskwargs)_get_axis_numberFrameRowApplyFrameColumnApplyreconstruct_func)r4   r5   r6   r7   r9   r;   r=   r?   rE   rF   klass_s               Q/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/pandas/core/apply.pyframe_applyrN   R   s     %%Dqyy	 $T44V44MAtQ5#
 
 
 
    c                     e Zd ZU ded<   ddddd@dZej        dAd            Zej        dBd            Zej        dBd            Z	dCdZ
dAd ZdDd"ZdAd#ZdAd$ZdEd*ZdFd/ZdAd0ZdGd4ZdHd9ZdAd:ZdAd;ZdId>ZdJd?ZdS )KApplyr   r6   r2   r3   Nr;   r=   r?   r4   r   r5   r   r7   r8   r9   r:   r;   #Literal[False, 'compat', '_compat']r=   r>   r?   r@   rA   Nonec                   || _         || _        |du s|dv sJ || _        |pd| _        |	pi | _        || _        |i n|| _        |dvrt          d          || _        || _	        d S )NF)r2   _compat )Nreduce	broadcastexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'})
r4   r7   r;   rE   rF   r=   r?   
ValueErrorr9   r5   )
selfr4   r5   r7   r9   r;   r=   r?   rE   rF   s
             rM   __init__zApply.__init__y   s     &,A"A"A"A"AJB	l#0#8RRmEEE=  
 '			rO   DataFrame | Seriesc                    d S NrW   r\   s    rM   applyzApply.apply       rO   op_nameLiteral['agg', 'apply']c                    d S r`   rW   r\   rd   s     rM   agg_or_apply_list_likezApply.agg_or_apply_list_like   	     	rO   c                    d S r`   rW   rg   s     rM   agg_or_apply_dict_likezApply.agg_or_apply_dict_like   ri   rO   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)r4   r5   rE   rF   
isinstancer>   	apply_strr   agg_dict_liker   agg_list_likecallablecomget_cython_funcwarn_alias_replacementgetattr)r\   r4   r5   rE   rF   fs         rM   aggz	Apply.agg   s     hyydC   	$>>### 	(%%'''$ 	(%%'''D>> 	)#D))A ) )f )&sD!444&wsA((( trO   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.
        rD   r   c                <    i | ]}t          j        |          p||S rW   rs   get_callable_name.0vs     rM   
<dictcomp>z#Apply.transform.<locals>.<dictcomp>   s*    GGGQ-a005AqGGGrO   c                    i | ]}|S rW   rW   )r~   colr5   s     rM   r   z#Apply.transform.<locals>.<dictcomp>   s    111cT111rO   zTransform function failedNzFunction did not transform)r4   r5   r6   rE   rF   ndimrG   T	transformr   r   r
   listr   r   transform_dict_liketransform_str_or_callable	TypeError	Exceptionr[   rn   r$   r"   emptyindexequals)	r\   r4   r6   rE   rF   	is_seriesresulterrr5   s	           @rM   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r,   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   rD   r   r6   )pandas.core.reshape.concatr   r4   rE   rF   rn   r#   lenr[   normalize_dictlike_argitems_gotitemr   )
r\   r5   r   r4   rE   rF   resultsnamehowcolgs
             rM   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&&&&rO   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
        rE   )r4   rE   rF   rn   r>   
_apply_strrs   rt   ru   rv   rb   r   )r\   r5   r4   rE   rF   rw   s         rM   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.
        rx   rd   )rh   ra   s    rM   rq   zApply.agg_list_like>       **5*999rO   selected_objSeries | DataFramerF   dict[str, Any](tuple[list[Hashable] | Index, 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 )aF  
        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.
        rD   )r   subsetN)r
   r   r   r5   r4   r   r   r   include_axisr6   rE   rv   appendrs   r|   	enumerateiloccolumnstake)r\   rd   r   rF   r5   r4   r   keysar   rE   new_resr   indicesr   r   s                   rM   compute_list_likezApply.compute_list_likeH  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}rO   r   Iterable[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   rD   F)r   r6   sortr.   r   r   z3cannot combine transform and aggregation operations)	r   r   r4   r   pandasr.   r   r   r[   )r\   r   r   r   r4   r   r.   r   s           rM   wrap_results_list_likezApply.wrap_results_list_like  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.
        rx   r   )rk   ra   s    rM   rp   zApply.agg_dict_like  r   rO   	selectionHashable | Sequence[Hashable] tuple[list[Hashable], list[Any]]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   rD   r   c                D    g | ]\  }} t                    |fi S rW   )rv   )r~   rL   r   r   rF   rd   s      rM   
<listcomp>z+Apply.compute_dict_like.<locals>.<listcomp>  s:    XXXC-wtW--c<<V<<XXXrO   c           
     x    g | ]6\  }}|D ].} t                              |d                     fi /7S )rD   r   )rv   _ixs)r~   labelr   indicer   rF   rd   r   s       rM   r   z+Apply.compute_dict_like.<locals>.<listcomp>  st       &w")   HGL--f1-==wGGVVvVV   rO   c           	     n    g | ]1\  }} t                              |d                     |fi 2S )rD   r   )rv   r   )r~   keyr   rF   r4   rd   s      rM   r   z+Apply.compute_dict_like.<locals>.<listcomp>  sY       C <Sq117;;CJJ6JJ  rO   )pandas.core.groupby.genericr   r   r4   rn   r
   r   r5   r   r   r   nuniquer   r   r   r   r   get_indexer_forr   r   zipr   )r\   rd   r   r   rF   r   r   
is_groupbyr5   is_non_unique_colr   r   r   r   labelslabel_to_indicesr   r   key_datar   r   r4   s    `` `              @@@rM   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}rO   result_indexlist[Hashable]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 rW   )rn   r#   )r~   rs     rM   r   z0Apply.wrap_results_dict_like.<locals>.<listcomp>  s"    EEEAjJ//EEErO   c                .    g | ]}|         j         |S rW   )r   r~   kr   s     rM   r   z0Apply.wrap_results_dict_like.<locals>.<listcomp>	  s%    KKK'!*:JK1KKKrO   r   rD   c                "    i | ]}||         S rW   rW   r   s     rM   r   z0Apply.wrap_results_dict_like.<locals>.<dictcomp>  s    4441GAJ444rO   )r6   r   zLcannot perform both aggregation and transformation operations simultaneouslyr   r.   r   )r   r-   r   r   r4   alldictr   r   
_set_namesr   namesrn   r$   anyr[   r.   r
   r   )r\   r   r   r   r-   r   r4   
is_ndframekeys_to_usektur6   r   r.   r   r   s                 @rM   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rO   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   Nr6   )corrwithskewz
Operation z does not support axis=1)idxmaxidxmin)r
   r>   r5   r4   r   r   r   rv   rr   inspectgetfullargspecrE   
kwonlyargsr6   r[   rn   rF   r   )	r\   r5   r4   r   r   methodsig	arg_namesdefault_axiss	            rM   ro   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DrO   c                   | j         dk    rt          d          | 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.
        numbazIThe 'numba' engine doesn't support list-like/dict likes of callables yet.rD   r   rE   rb   r   )r=   NotImplementedErrorr6   rn   r4   r"   r   rb   r5   rE   rF   r   rk   rh   reconstruct_and_relabel_result)r\   r5   rF   r   s       rM   apply_list_or_dict_likezApply.apply_list_or_dict_like]  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rO   r   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.
        )rb   rx   r   rx   c              3  :   K   | ]\  }}t          |          V  d S r`   )r   r~   rL   r   s      rM   	<genexpr>z/Apply.normalize_dictlike_arg.<locals>.<genexpr>  s,      ==1LOO======rO   c              3  :   K   | ]\  }}t          |          V  d S r`   )r   r   s      rM   r   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>  s,      ;;da,q//;;;;;;rO   znested renamer is not supportedrD   r   r   T)r   z
Column(s) z do not existc              3  >   K   | ]\  }}t          |          V  d S r`   )rn   )r~   rL   xaggregator_typess      rM   r   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>  s2      HH41az!-..HHHHHHrO   )rn   r$   r   r   r   r   r   r-   r   r   
differencer   r   KeyErrortupler   )
r\   r   r4   r5   r-   colsnew_funcr   r   r  s
            @rM   r   zApply.normalize_dictlike_arg|  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rO   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   rW   )r~   kwargs     rM   r   z$Apply._apply_str.<locals>.<listcomp>  s"    KKK%U(5J5J5J5J5JrO   	__array__'z' is not a valid function for 'z' object)
rn   r>   hasattrrv   rr   r   nptype__name__AttributeError)r\   r4   r5   rE   rF   rw   msgs          rM   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 %%%rO   )r4   r   r5   r   r7   r8   r9   r:   r;   rS   r=   r>   r?   r@   rA   rT   rA   r^   rd   re   rA   r^   )rA   rl   )rA   r,   )rd   re   r   r   rF   r   rA   r   )r   r   r   r   )
rd   re   r   r   r   r   rF   r   rA   r   )r   r   r   r   r   r   )r   r>   r4   r^   r5   r   rA   r   )r5   r>   )r  
__module____qualname____annotations__r]   abcabstractmethodrb   rh   rk   rx   r   r   r   rq   r   r   rp   r   r   ro   r   r   r   rW   rO   rM   rQ   rQ   v   s        MMM 7?04! ! ! ! ! !F 	    	   
 	   
   @A A A AF' ' ' '0. . . ..: : : :@ @ @ @D   *: : : :M M M M^4 4 4 4l-E -E -E -E^   >+ + + +Z& & & & & &rO   rQ   )	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
    r^   r4   rA   r-   c                    | j         j        S r`   )r4   r   ra   s    rM   r   zNDFrameApply.index  s    x~rO   c                @    | j                             | j                  S r`   )r4   _get_agg_axisr6   ra   s    rM   agg_axiszNDFrameApply.agg_axis  s    x%%di000rO   rd   re   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 )	Nrb   rV   Fr;   r6   r   rD   "axis other than 0 is not supported)
r4   rF   rn   rB   r;   SeriesApplyrv   r   r   r   )r\   rd   r4   rF   r;   r   r   r   s           rM   rh   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;;rO   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rx   rb   rb   rV   Fr;   r6   r   rD   r$  )r4   r;   updaterv   r   r   r   )	r\   rd   r4   rF   r;   r   r   r   r   s	            rM   rk   z#NDFrameApply.agg_or_apply_dict_like  s     *****hg"&+8YY5FMM8V,---3""a''%&JKKK	$($:$:S)V%
 %
!k ,,S,LLrO   NrA   r-   r  )
r  r  r  __doc__r  propertyr   r"  rh   rk   rW   rO   rM   r  r    s          
    X 1 1 1 X1   .     rO   r  c                      e Zd ZU ded<   ddddd5 fdZeej        d6d                        Zeej        d6d                        Z	eej        d7d                        Z
eej        ej        	 d8d9d                                    Zej        d             Zd  Zej        d:d%            Zed6d&            Zed6d'            Zed(             Zd;d)Z fd*Zd+ Zd<d,Zd=d.Zd/ Zd>d1Zd2 Zd:d3Zd; fd4Z xZ S )?rB   r,   r4   Fr3   NrR   r   r5   r   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rT   c                   |dur|dk    rt          d| d          t                                          |||||||||		  	         d S )NFr2   zby_row=z not allowed)r;   r=   r?   rE   rF   )r[   superr]   )r\   r4   r5   r7   r9   r;   r=   r?   rE   rF   	__class__s             rM   r]   zFrameApply.__init__  sz     6X#5#5;v;;;<<<' 	 
	
 
	
 
	
 
	
 
	
rO   r-   c                    d S r`   rW   ra   s    rM   r   zFrameApply.result_index#  	     	rO   c                    d S r`   rW   ra   s    rM   result_columnszFrameApply.result_columns(  r1  rO   Generator[Series, None, None]c                    d S r`   rW   ra   s    rM   series_generatorzFrameApply.series_generator-  r1  rO   T5Callable[[npt.NDArray, Index, Index], dict[int, Any]]c                    d S r`   rW   )r5   nogilnopythonparallels       rM   generate_numba_apply_funcz$FrameApply.generate_numba_apply_func2  s	     	rO   c                    d S r`   rW   ra   s    rM   apply_with_numbazFrameApply.apply_with_numba:  rc   rO   c                    | j         j                                        D ]L\  }}t          |          st	          d| d| d          t          |          rt	          d| d          Md S )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.)r4   dtypesr   r   r[   r   )r\   colnamedtypes      rM   validate_values_for_numbaz$FrameApply.validate_values_for_numba>  s    "ho3355 
	 
	NGU#E**  /g / /#/ / /   (..  Cg C C C  
	 
	rO   r   ResType	res_indexr^   c                    d S r`   rW   r\   r   rE  s      rM   wrap_results_for_axisz FrameApply.wrap_results_for_axisL  ri   rO   c                    | j         S r`   )r3  ra   s    rM   res_columnszFrameApply.res_columnsT  s    ""rO   c                    | j         j        S r`   )r4   r   ra   s    rM   r   zFrameApply.columnsX  s    xrO   c                    | j         j        S r`   )r4   valuesra   s    rM   rM  zFrameApply.values\  s    xrO   c                H   t          | j                  r.| j        dk    rt          d          |                                 S t          | j                  dk    r,t          | j                  dk    r|                                 S t          | j        t                    r.| j        dk    rt          d          |                                 S t          | j        t          j                  r| j        dk    rt          d          t          j        d          5  | j        j                            d| j        	          }d
d
d
           n# 1 swxY w Y   | j                            ||j                  S | j        dk    r4| j        dk    rt          d          |                     | j                  S t-          | j        j                  s|                                 S | j        r!|                     | j        | j                  S |                                 S )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   rb   )r5   N)axesrY   z:the 'numba' engine doesn't support result_type='broadcast'r=   r?   )r   r5   r=   r   r   r   r   r   apply_empty_resultrn   r>   ro   r  ufuncerrstater4   _mgrrb   _constructor_from_mgrrQ  r9   apply_broadcastr   shaper7   	apply_rawr?   apply_standardr\   r   s     rM   rb   zFrameApply.apply`  sw    	"" 	2{g%%)O   //111 t|!!c$*oo&:&:**,,, di%% 	N{g%%)8   >>### 	28,, 		N{g%%)C   *** 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 {**{g%%)P   ''111 TX^$$ 	X**,,, X 	X>>DDV>WWW""$$$s   'EEE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   rD   rE   )	r4   r6   r   r.  rx   rb   r5   rE   rF   )r\   r4   r6   r   r/  s       rM   rx   zFrameApply.agg  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
        )rX   NrX   r   r   rB  )r   rB  r   )rr   r5   r9   r4   copyr   r.   r6   r  float64rE   rF   r   rn   r   r   r"  nan_constructor_sliced)r\   should_reducer.   r   s       rM   rS  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 }|dk    rC|i n|}t          | j        fi |} || j        | j                  }t	          j        |          }n9t	          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 )Nr_  )rn   r>   r  arrayobject)rE   rF   r   r5   s      rM   wrapperz<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapper  sB    t.v..fc** <XfF;;;FrO   rW   )r5   rk  s   ` rM   wrap_functionz+FrameApply.apply_raw.<locals>.wrap_function  s#         NrO   r   Nr   r   r   r`  )r%   r5   rM  r6   r  squeezeapply_along_axisrE   rF   r   r4   _constructorr   r   rd  r"  )r\   r=   r?   rl  	nb_looperr   s         rM   rZ  zFrameApply.apply_raw  s   	 	 	 W"/"7BB]M .	 * I Yt{DI66FZ''FF(di((	 	  
 + F ;!8((tz4<(XXX8//dm/LLLrO   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   rD   ztoo many dims to broadcastzcannot broadcast resultrm  )rr   r5   r  
empty_likerM  rY  r   r   rE   rF   asarrayr   r[   r   r4   rp  r   )	r\   rr  result_valuesresult_compareir   resaresr   s	            rM   rX  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~ ' 
 
 rO   c                    | j         dk    r|                                 \  }}n|                                 \  }}|                     ||          S )Nr3   )r=   apply_series_generatorapply_series_numbawrap_resultsrG  s      rM   r[  zFrameApply.apply_standard%  sU    ;(""!%!<!<!>!>GYY!%!8!8!:!:GY   )444rO   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)rr   r5   r6  r   r   r   rE   rF   rn   r$   ra  )r\   
series_genrE  r   rx  r   s         rM   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                   | j                             dd          rt          d          | j        j        j        r| j        j        st          d          |                                  |                                 }|| j	        fS )Nr;  FzAParallel apply is not supported when raw=False and engine='numba'zBThe index/columns must be unique when raw=False and engine='numba')
r?   getr   r4   r   	is_uniquer   rC  r>  r   r\  s     rM   r}  zFrameApply.apply_series_numbaA  s    !!*e44 	%S   x~' 	t|/E 	%T   	&&((('')))))rO   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   r_  )
r   r.   r   r   rH  r4   rd  r  rb  r   )r\   r   rE  r.   constructor_slicedr   s         rM   r~  zFrameApply.wrap_resultsN  s    !!!!!! w<<!WWQZ1H1H--gyAAA "X9w<<1!3v!=!=''rzBBBFF''00F rO   c                    | j         dk    r5| j        }|j        | j                 }|                    || j                  S t                                                      S )Nsizer`  )r5   r4   rY  r6   rd  r"  r.  ro   )r\   r4   valuer/  s      rM   ro   zFrameApply.apply_strc  sX     9(CIdi(E**5*FFFww  """rO   )r4   r   r5   r   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rT   r)  rA   r4  TTFrA   r7  r   rD  rE  r-   rA   r^   r  )r3   Nrr  r,   rA   r,   )rA   r  )!r  r  r  r  r]   r+  r  r  r   r3  r6  staticmethod	functoolscacher<  r>  rC  rH  rJ  r   r   rM  rb   rx   rS  rZ  rX  r[  r|  r}  r~  ro   __classcell__r/  s   @rM   rB   rB     s        NNN ,104
 
 
 
 
 
 
 
<     X     X     X _27     _ \
 	     	    # # # X#       X    ^4% 4% 4% 4%l    .,# ,# ,#\,M ,M ,M ,M\   85 5 5" " " "&* * *   *# # # # # # # # # #rO   c                      e Zd ZU dZded<   edd            Zeej	        	 ddd
                        Z
ddZedd            Zedd            ZddZdS )rH   r   r   r6   rA   r4  c                ^      fdt          t           j                            D             S )Nc              3  P   K   | ] }j                             |d           V  !dS )rD   r   N)r4   r   )r~   rx  r\   s     rM   r   z1FrameRowApply.series_generator.<locals>.<genexpr>s  s5      KKQaa((KKKKKKrO   )ranger   r   ra   s   `rM   r6  zFrameRowApply.series_generatorq  s/    KKKK%DL8I8I2J2JKKKKrO   TFr7  c                    t          d          }ddlm ddlm |j                            |           |                    |||          fd            }|S )Nr   r   r   maybe_cast_strr9  r:  r;  c           	         i }t          | j        d                   D ]7} | d d |f         | ||                             } |          ||<   8|S )NrD   r   )r  rY  )	rM  	col_namesdf_indexr   jserr.   
jitted_udfr  s	         rM   
numba_funcz;FrameRowApply.generate_numba_apply_func.<locals>.numba_func  sw    G6<?++ - -f111a4L~~iPQl7S7S   (Z__

NrO   r   r   r.   pandas.core._numba.extensionsr  	extendingregister_jitablejit	r5   r9  r:  r;  r   r  r.   r  r  s	         @@@rM   r<  z'FrameRowApply.generate_numba_apply_funcu  s    
 +733!!!!!! 	A@@@@@_55d;;
 
H	E	E	 	 	 	 	 	 
F	E	 rO   dict[int, Any]c           	     b    | j         t          t          | j                  fi | j        }ddlm} | j        j        }| j        j	        } ||          5 } ||          5 }t           || j        ||                    }d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   |S Nr   )set_numba_datar<  r
   r   r5   r?   r  r  r4   r   r   r   rM  r\   nb_funcr  r   r   ry  s         rM   r>  zFrameRowApply.apply_with_numba  sD   0$049%%
 
)-);
 
 	A@@@@@(" ^E"" 	=e^^G-D-D 	=wwt{GU;;<<C	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	=
s6   B$! BB$B	B$B	B$$B(+B(r-   c                    | j         S r`   r   ra   s    rM   r   zFrameRowApply.result_index  
    |rO   c                    | j         S r`   r`  ra   s    rM   r3  zFrameRowApply.result_columns  
    zrO   r   rD  rE  r^   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 rowsrX   Nc              3  @   K   | ]}t          |t                    V  d S r`   )rn   r   )r~   r  s     rM   r   z6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>  s=       .
 .
$%Jq$.
 .
 .
 .
 .
 .
rO   dataz%All arrays must be of the same lengthr   )r9   r4   rd  r   r   rM  rp  r[   r>   rn   r$   r   rJ  r   )r\   r   rE  ry  r   r   s         rM   rH  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  r  r  rA   r  r)  r  )r  r  r  r6   r  r+  r6  r  r  r  r<  r>  r   r3  rH  rW   rO   rM   rH   rH   n  s         DL L L XL _27    _ \6       X    X' ' ' ' ' 'rO   rH   c                       e Zd ZU dZded<   d fdZedd	            Zee	j
        	 ddd                        ZddZedd            Zedd            ZddZd dZ xZS )!rI   rD   r   r6   rr  r,   rA   c                ^    t                                          |j                  }|j        S r`   )r.  rX  r   )r\   rr  r   r/  s      rM   rX  z FrameColumnApply.apply_broadcast  s#    ((22xrO   r4  c              #    K   | j         }t          |          }t          |          dk    sJ | j                            dd          }|j        }|j        d         j                                        }t          |j
        t                    rA| j        }t          t          |                    D ]}|                    |d          V  d S t          || j                  D ]m\  }}||_        |                    |           t                               |d|           |s*t%          |j        d                   |j        d         _        |V  nd S )Nr   r   _name)rM  r&   r   r4   r   rV  blocksrefshas_referencern   rB  r!   r  r   r   
set_valuesrj  __setattr__r   )	r\   rM  r  mgris_viewr4   rx  arrr   s	            rM   r6  z!FrameColumnApply.series_generator  sV     /776{{Q hmmAAm&&h*Q-$2244ci00 	 (C3s88__ * *hhqqh))))))* * !44  	Ts###""3666 H *9A)G)GCJqM&				 rO   TFr7  c                    t          d          }ddlm ddlm |j                            |           |                    |||          fd            }|S )Nr   r   r   r  r  c           	         i }t          | j        d                   D ]E} | |                                         | ||                             } |          ||<   F|S )Nr   r   )r  rY  ra  )	rM  col_names_indexr   r   rx  r  r.   r  r  s	         rM   r  z>FrameColumnApply.generate_numba_apply_func.<locals>.numba_func	  s~    G 6<?++ - - f1INN$$)'a11  
 (Z__

NrO   r  r  s	         @@@rM   r<  z*FrameColumnApply.generate_numba_apply_func  s    
 +733!!!!!!@@@@@@_55d;;
	H	E	E	 	 	 	 	 	 
F	E	  rO   r  c           	     P    | j         t          t          | j                  fi | j        }ddlm}  || j        j                  5 } || j	                  5 }t           || j        ||                    }d d d            n# 1 swxY w Y   d d d            n# 1 swxY w Y   |S r  r  r  s         rM   r>  z!FrameColumnApply.apply_with_numba  s?   0$049%%
 
)-);
 
 	A@@@@@ ^DHN++ 	=unnL7
 7
 	=wwt{GU;;<<C	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	= 	=
 
s6   B B8BB	BB	BB"Br-   c                    | j         S r`   r`  ra   s    rM   r   zFrameColumnApply.result_index,  r  rO   c                    | j         S r`   r  ra   s    rM   r3  zFrameColumnApply.result_columns0  r  rO   r   rD  rE  r^   c                    | j         dk    r|                     ||          }nSt          |d         t                    s"| j                            |          }||_        n|                     ||          }|S )z"return the results for the columnsrZ   r   )r9   infer_to_same_shapern   r$   r4   rd  r   r\   r   rE  r   s       rM   rH  z&FrameColumnApply.wrap_results_for_axis4  s|     x''--gyAAFF GAJ	22 	BX11'::F$FLL --gyAAFrO   c                    | j                             |          }|j        }||_        |                    d          }|S )z7infer the results to the same shape as the input objectr  Fra  )r4   rp  r   r   infer_objectsr  s       rM   r  z$FrameColumnApply.infer_to_same_shapeI  sG    &&G&44 ! %%5%11rO   r  r  r  r  r  r)  r  )r   rD  rE  r-   rA   r,   )r  r  r  r6   r  rX  r+  r6  r  r  r  r<  r>  r   r3  rH  r  r  r  s   @rM   rI   rI     s!        D      ! ! ! X!F _27    _ \8        X    X   *       rO   rI   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.   r4   r   r   r6   rS   r;   r2   )convert_dtyper;   r5   r   r  bool | lib.NoDefaultrA   rT   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``.
stacklevelF)r7   r9   r;   rE   rF   )	r   
no_defaultwarningswarnFutureWarningr   r  r.  r]   )r\   r4   r5   r  r;   rE   rF   r/  s          rM   r]   zSeriesApply.__init__\  s     CN** MMM? +--    + 	 	
 	
 	
 	
 	
rO   r^   c                p   | j         }t          |          dk    r|                                 S t          | j                  r|                                 S t          | j        t                    r|                                 S | j	        dk    r| 
                                S |                                 S )Nr   rV   )r4   r   rS  r   r5   r   rn   r>   ro   r;   apply_compatr[  r\   r4   s     rM   rb   zSeriesApply.apply|  s    hs88q==**,,, 	"" 	2//111di%% 	$>>###;)##$$&&& ""$$$rO   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 )NrE   zusing z in z3.agg cannot aggregate and has been deprecated. Use z&.transform to keep behavior unchanged.r  )r.  rx   r4   r5   rr   rb   rE   rF   r  r  r  r  r  r   r[   r  r   )r\   r   r4   r5   r  r/  s        rM   rx   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)rB  r   rb   r   )r4   rp  rB  r   __finalize__r  s     rM   rS  zSeriesApply.apply_empty_result  sC    hcisyAANN O 
 
 	
rO   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
        F)r;   r2   )r4   r5   rr   rs   rt   rE   rF   rb   r[   r  r   )r\   r4   r5   rw   r   s        rM   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 )	NrO  rP  c                0     | gj         R i j        S r`   )rE   rF   )r  r5   r\   s    rM   curriedz+SeriesApply.apply_standard.<locals>.curried  s'    tA9	999T[999rO   )mapper	na_actionconvertr   r`  rb   r  )r
   r   r5   r4   rn   r  rT  rU  rE   rF   r;   rB  r    _map_valuesr  r   r$   _constructor_expanddimr   r   rp  r  )r\   r4   r  actionmappedr5   s   `    @rM   r[  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:)
r4   r.   r5   r   r  r  r;   rS   rA   rT   r  )rA   r.   )r  r  r  r  r6   r   r  r]   rb   rx   rS  r  r[  r  r  s   @rM   r%  r%  W  s         KKKD//// /2n6>
 
 
 
 
 
 
 
@% % % %(    2
 
 
 
  ,$ $ $ $ $ $ $ $rO   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 | BaseWindowr4   GroupBy[NDFrameT]r5   r   rA   rT   c                   |                                 }|j                            |                    dd                    | _        t                                          ||dd ||           d S )Nr6   r   Fr7   r9   rE   rF   )ra  r4   rG   r  r6   r.  r]   r\   r4   r5   rE   rF   r/  s        rM   r]   zGroupByApply.__init__  st     G,,VZZ-B-BCC	 	 	
 	
 	
 	
 	
rO   c                    t           r`   r   ra   s    rM   rb   zGroupByApply.apply      !!rO   c                    t           r`   r  ra   s    rM   r   zGroupByApply.transform  r  rO   rd   re   r^   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 )Nrb   r;   Fr6   r   rD   r$  as_indexT	condition)r4   rF   rv   r   _selected_objr   _obj_with_exclusionsrs   temp_setattrr  r   r   )r\   rd   r4   rF   r   r   r   r   s           rM   rh   z#GroupByApply.agg_or_apply_list_like  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'  rb   rV   Fr;   r6   rD   r$  r=   r?   rR  r  Tr  )r   r   r   r4   r;   r(  rv   r   r  
_selectionrn   rF   r  rs   r  r  r   r   )r\   rd   r   r   r4   rF   r;   r   r   r   r=   r?   r   r   r   s                  rM   rk   z#GroupByApply.agg_or_apply_dict_like"  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&)r4   r  r5   r   rA   rT   r  )
r  r  r  r  r]   rb   r   rh   rk   r  r  s   @rM   r  r    s         ))))
 
 
 
 
 
&" " "" " "   4% % % % % % % %rO   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   r6   Resampler | BaseWindowr4   r5   r   rA   rT   c               d    t          t          |                               ||dd ||           d S )NFr  )r.  r  r]   r  s        rM   r]   zResamplerWindowApply.__init__N  sH     	lD!!** 	+ 	
 	
 	
 	
 	
rO   c                    t           r`   r  ra   s    rM   rb   zResamplerWindowApply.apply_  r  rO   c                    t           r`   r  ra   s    rM   r   zResamplerWindowApply.transformb  r  rO   )r4   r  r5   r   rA   rT   )	r  r  r  r6   r  r]   rb   r   r  r  s   @rM   r  r  J  sz         D
 
 
 
 
 
"" " "" " " " " " "rO   r  AggFuncType | NoneMtuple[bool, AggFuncType, tuple[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: 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).rW   )is_multi_agg_with_relabelrn   r   r   setr   r   normalize_keyword_aggregation)r5   rF   
relabelingr   orders        rM   rJ   rJ   f  s    N E";"E"Ef"E"EJ&*G)-E 
TdD!! 	c$ii#c$ii..&@&@ %   <RSSS 
  = 
  
gu tWe++rO   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)rn   r  r   r}   s     rM   r   z,is_multi_agg_with_relabel.<locals>.<genexpr>  s;      MMz!U##3A!MMMMMMrO   r   )r   rM  r   )rF   s    rM   r  r    s=    * MMV]]__MMMMM FarO   rF   r   ]tuple[MutableMapping[Hashable, list[AggFuncTypeBase]], tuple[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 )aR  
    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   c                N    g | ]"\  }}|D ]}|t          j        |          p|f#S rW   r{   )r~   columnaggfuncsaggfuncs       rM   r   z1normalize_keyword_aggregation.<locals>.<listcomp>  sX       FH   
&w//:7;   rO   )pandas.core.indexes.baser-   r   r   r   r   r   rs   r|   _make_unique_kwarg_listget_indexer)rF   r-   aggspecr  r   pairsr  r  uniquified_orderaggspec_orderuniquified_aggspeccol_idx_orders               rM   r  r    s   < /.....
 $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]**rO   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 )rD   r   rL   N)count)r~   rx  pairr!  s      rM   r   z+_make_unique_kwarg_list.<locals>.<listcomp>  sv       At :=419L9LaT!W44s2A2w}}T224455RV  rO   )r   )r!  s   `rM   r  r    s4        ~~   rO   r   r^   dict[str, list[Callable | str]]r   r   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   rW   )r~   r&  s     rM   r   z"relabel_result.<locals>.<listcomp>9  s)       Q  rO   c                    | d         S )NrD   rW   )ts    rM   <lambda>z relabel_result.<locals>.<lambda>:  s
    ad rO   )r   rD   c                d    g | ]-}t          |t                    st          j        |          n|.S rW   )rn   r>   rs   r|   )r~   rw   s     rM   r   z"relabel_result.<locals>.<listcomp>X  sD       NO
1c0B0BI%a(((  rO   Fr  )r  r-   sortedr   rn   r$   r   r   r   dropnar   r  r   reindex)r   r5   r   r  r-   reordered_indexesreordered_result_in_dictidxreorder_maskr   funsr   s                rM   relabel_resultr9    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##rO   c                    ddl m} t          |fi |\  }}}}|r'|J |J t          | |||          } |||          } | S )Nr   )r,   r`  )r   r,   rJ   r9  )r   r5   rF   r,   r  r   r  result_in_dicts           rM   r   r   f  s          '7'G'G'G'G$Jgu 
: """   'guEE>999MrO   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.
    rD   r   z<lambda>z<lambda_>)r   rs   r|   r   r  r   )r  rx  mangled_aggfuncsr  s       rM   _managle_lambda_listr@    s    $ 8}}	A ) ) ))Z77g&&G.!GFA((((rO   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@  )rA  is_dictmangled_aggspecr   r  r?  s         rM   maybe_mangle_lambdasrE    s    2 8$$G |H-- $d8nn&&O 	9%^^-- 	4 	4MCH%% ,l8.D.D ,#7#A#A  #+ #3OC  	4 /x88rO   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   rM  rn   r>   rr   r   formatr  r  r   )rF   tuple_given_messager   r5   col_funcno_arg_messages         rM   validate_func_kwargsrL    s    . J6llGDMMOO  8S)) 	QXh-?-? 	Q/66tH~~7NOOPPPH (M'''D=rO   rd   re   r   r   c                b    t          |t                    pt          |t                    o| dk    S )Nrx   )rn   r"   r$   )rd   r   s     rM   r   r     s0    dL)) 4##85(8rO   r   r   aliasrT   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   )r4   r5   rN  
full_aliass       rM   ru   ru     s    
  

S		*44U44
EM	5 	5 	5	5 	5 %*	5 	5 	5 #%%     rO   )r   FNr2   r3   NNN)r4   r,   r5   r   r6   r   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   )r5   r  rA   r	  )rA   r8   )rF   r   rA   r  )r!  r"  rA   r"  )
r   r^   r5   r'  r   r   r  r(  rA   r)  r  )r  r<  rA   r<  )rA  r   rA   r   )rF   r   rA   rF  )rd   re   r   r   rA   r8   )r4   r   r5   r   rN  r>   rA   rT   )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commonrs   pandas.core.constructionr&   collections.abcr'   r(   r)   r*   r+   r   r,   r-   r.   pandas.core.groupbyr/   pandas.core.resampler0   pandas.core.window.rollingr1   r   intrD  rN   ABCMetarQ   r  rB   rH   rI   r%  r  r  rJ   r  r  r  r9  r   r@  rE  rL  r   ru   rW   rO   rM   <module>rp     s   " " " " " " 



 # # # # # #                              ) ) ) ) ) )       2 2 2 2 2 2	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ? > > > > > , , , , , , 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. "'/,0	! ! ! ! !HL	& L	& L	& L	& L	&ck L	& L	& L	& L	&^: : : : :5 : : :zi# i# i# i# i# i# i# i#Xb b b b bJ b b bJA A A A Az A A AHR R R R R, R R Rj[ [ [ [ [5 [ [ [|" " " " "< " " "8B, B, B, B,J   4:+ :+ :+ :+z   $O$ O$ O$ O$d   6   B) ) ) )X! ! ! !H        rO   