Ë
    ¤eh ã                  ób  — 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	 	 	 	 	 	 	 	 d6	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d7d„ZR G d„ dej¦                  ¬«      ZT G d„ deT«      ZU G d „ deU«      ZV G d!„ d"eV«      ZW G d#„ d$eV«      ZX G d%„ d&eU«      ZY G d'„ d(eT«      ZZ G d)„ d*eZ«      Z[	 	 	 	 d8d+„Z\d9d,„Z]	 	 	 	 d:d-„Z^	 	 	 	 d;d.„Z_	 	 	 	 	 	 	 	 	 	 d<d/„Z`d=d0„Zad>d1„Zbd?d2„Zc	 	 	 	 d@d3„ZddAd4„Ze	 	 	 	 	 	 	 	 dBd5„Zfy)Cé    )ÚannotationsN)Údefaultdict)Úpartial)ÚTYPE_CHECKINGÚAnyÚCallableÚLiteralÚcast)Úoption_context)Úlib)ÚBlockValuesRefs)ÚAggFuncTypeÚAggFuncTypeBaseÚAggFuncTypeDictÚ
AggObjTypeÚAxisÚAxisIntÚNDFrameTÚnpt)Úimport_optional_dependency)ÚSpecificationError)Úcache_readonly)Úfind_stack_level)Úis_nested_object)Úis_dict_likeÚis_extension_array_dtypeÚis_list_likeÚis_numeric_dtypeÚis_sequence)ÚCategoricalDtypeÚExtensionDtype)ÚABCDataFrameÚ
ABCNDFrameÚ	ABCSeries)Úgenerate_apply_looper)Úensure_wrapped_if_datetimelike)Ú	GeneratorÚHashableÚIterableÚMutableMappingÚSequence)Ú	DataFrameÚIndexÚSeries)ÚGroupBy)Ú	Resampler)Ú
BaseWindowÚ
FrameApplyc
                óž   — | j                  |«      }|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   é   )ÚrawÚresult_typeÚby_rowÚengineÚengine_kwargsÚargsÚkwargs)Ú_get_axis_numberÚFrameRowApplyÚFrameColumnApplyÚreconstruct_func)ÚobjÚfuncÚaxisr5   r6   r7   r8   r9   r:   r;   ÚklassÚ_s               úO/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/apply.pyÚframe_applyrF   R   sw   € ð ×Ñ Ó%€Dàˆq‚yÜ‰Ø	�ŠÜ ˆä$ TÑ4¨VÑ4�M€A€tˆQ�ØÐÐÐáØØØØØØØ#ØØô
ð 
ó    c                  ó‚  — e Zd ZU ded<   ddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zej                  dd„«       Zej                  	 	 	 	 dd	„«       Zej                  	 	 	 	 dd
„«       Z	dd„Z
dd„Zdd„Zdd„Zdd„Z	 	 	 	 	 	 	 	 dd„Z	 	 	 	 dd„Zdd„Z	 	 	 	 	 	 	 	 	 	 d d„Z	 	 	 	 	 	 d!d„Zdd„Zdd„Z	 	 	 	 	 	 	 	 d"d„Zd#d„Zy)$ÚApplyr   rB   ÚcompatÚpythonN©r7   r8   r9   c               óÌ   — || _         || _        |du s|dv sJ ‚|| _        |xs d| _        |	xs i | _        || _        |€i n|| _        |dvrt        d«      ‚|| _        || _	        y )NF)rJ   Ú_compat© )NÚreduceÚ	broadcastÚexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'})
r@   r5   r7   r:   r;   r8   r9   Ú
ValueErrorr6   rA   )
Úselfr@   rA   r5   r6   r7   r8   r9   r:   r;   s
             rE   Ú__init__zApply.__init__y   s†   € ð ˆŒØˆŒà˜‰ &Ð,AÑ"AÐAÐAØˆŒà’J˜BˆŒ	Ø’l ˆŒàˆŒØ#0Ð#8™R¸mˆÔàÐEÑEÜð=óð ð
 'ˆÔàˆ�	rG   c                 ó   — y ©NrO   ©rT   s    rE   ÚapplyzApply.applyœ   ó   € àrG   c                 ó   — y rW   rO   ©rT   Úop_names     rE   Úagg_or_apply_list_likezApply.agg_or_apply_list_like    ó   € ð 	rG   c                 ó   — y rW   rO   r\   s     rE   Úagg_or_apply_dict_likezApply.agg_or_apply_dict_like¦   r_   rG   c                ó˜  — | j                   }| j                  }| j                  }| j                  }t	        |t
        «      r| j                  «       S t        |«      r| j                  «       S t        |«      r| j                  «       S t        |«      r9t        j                  |«      }|r"|s |st        |||«        t        ||«      «       S y)z»
        Provide an implementation for the aggregators.

        Returns
        -------
        Result of aggregation, or None if agg cannot be performed by
        this method.
        N)r@   rA   r:   r;   Ú
isinstanceÚstrÚ	apply_strr   Úagg_dict_liker   Úagg_list_likeÚcallableÚcomÚget_cython_funcÚwarn_alias_replacementÚgetattr)rT   r@   rA   r:   r;   Úfs         rE   Úaggz	Apply.agg¬   s­   € ð �h‰hˆØ�y‰yˆØ�y‰yˆØ—‘ˆä�dœCÔ Ø—>‘>Ó#Ð#ä˜ÔØ×%Ñ%Ó'Ð'Ü˜$Ôà×%Ñ%Ó'Ð'ä�DŒ>Ü×#Ñ# DÓ)ˆAÙ™¡fÜ& s¨D°!Ô4Ø&”w˜s A“Ó(Ð(ð rG   c                óê  — | j                   }| j                  }| j                  }| j                  }| j                  }|j
                  dk(  }|j                  |«      dk(  r/|rJ ‚ |j                  j                  |dg|¢­i |¤Žj                  S t        |«      r\t        |«      sQt        t        t           |«      }|r(|D �ci c]  }t        j                  |«      xs ||“Œ }}n|D �ci c]  }||“Œ }}t        |«      r!t        t         |«      }| j#                  |«      S t        t        |«      }	 | j%                  |«      }	t-        |	t.        t0        f«      r#|	j2                  r|j2                  st+        d«      ‚t-        |	t.        t0        f«      r%|	j4                  j7                  |j4                  «      st+        d«      ‚|	S c c}w c c}w # t&        $ r ‚ t(        $ r}
t+        d«      |
‚d}
~
ww xY w)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.
        r4   r   zTransform function failedNzFunction did not transform)r@   rA   rB   r:   r;   Úndimr<   ÚTÚ	transformr   r   r
   Úlistr   ri   Úget_callable_namer   Útransform_dict_likeÚtransform_str_or_callableÚ	TypeErrorÚ	ExceptionrS   rc   r$   r"   ÚemptyÚindexÚequals)rT   r@   rA   rB   r:   r;   Ú	is_seriesÚvÚcolÚresultÚerrs              rE   rr   zApply.transformÌ   sÊ  € ð �h‰hˆØ�y‰yˆØ�y‰yˆØ�y‰yˆØ—‘ˆà—H‘H ‘Mˆ	à×Ñ Ó%¨Ò*Ù Ð �=Ø"�3—5‘5—?‘? 4¨Ð<¨TÒ<°VÑ<×>Ñ>Ð>ä˜Ô¤l°4Ô&8Üœœ_Ñ-¨tÓ4ˆDáØBFÖG¸Qœ×-Ñ-¨aÓ0Ò5°A°qÑ8ÐG�ÑGà-0Ö1 c˜˜T™	Ð1�Ð1ä˜ÔÜœ¨Ó.ˆDØ×+Ñ+¨DÓ1Ð1ô ”O TÓ*ˆð	CØ×3Ñ3°DÓ9ˆFô �v¤	¬<Ð8Ô9Ø—’Ø—I’IäÐ8Ó9Ð9ô
 ˜&¤9¬lÐ";Ô<ÀFÇLÁL×DWÑDWØ�I‰IôE
ô Ð9Ó:Ð:àˆùòE Hùâ1øô ò 	ØÜò 	CÜÐ8Ó9¸sÐBûð	Cús$   Ã!GÃ*
G
Ä3G ÇG2Ç!G-Ç-G2c                ót  — ddl m} | j                  }| j                  }| j                  }t        |t        «      sJ ‚t        |«      dk(  rt        d«      ‚| j                  d||«      }i }|j                  «       D ]2  \  }}|j                  |d¬«      }	 |	j                  |dg|¢­i |¤Ž||<   Œ4  ||d¬«      S )zC
        Compute transform in the case of a dict-like func
        r   ©Úconcatz$No transform functions were providedrr   r4   ©rp   ©rB   )Úpandas.core.reshape.concatrƒ   r@   r:   r;   rc   r#   ÚlenrS   Únormalize_dictlike_argÚitemsÚ_gotitemrr   )
rT   rA   rƒ   r@   r:   r;   ÚresultsÚnameÚhowÚcolgs
             rE   ru   zApply.transform_dict_like  sÀ   € õ 	6à�h‰hˆØ�y‰yˆØ—‘ˆô ˜#œzÔ*Ð*Ð*äˆt‹9˜Š>ÜÐCÓDÐDà×*Ñ*¨;¸¸TÓBˆà68ˆØŸ™›ò 	D‰IˆD�#Ø—<‘< ¨1�<Ó-ˆDØ*˜DŸN™N¨3°ÐC°DÒC¸FÑCˆG�DŠMð	Dñ �g AÔ&Ð&rG   c                ól  — | j                   }| j                  }| j                  }t        |t        «      r | j
                  ||g|¢­i |¤ŽS |s7|s5t        j                  |«      }|rt        |||«        t        ||«      «       S 	  |j                  |fd|i|¤ŽS # t        $ r  ||g|¢­i |¤ŽcY S w xY w)zL
        Compute transform in the case of a string or callable func
        r:   )r@   r:   r;   rc   rd   Ú
_apply_strri   rj   rk   rl   rY   rx   )rT   rA   r@   r:   r;   rm   s         rE   rv   zApply.transform_str_or_callable'  s¿   € ð �h‰hˆØ�y‰yˆØ—‘ˆä�dœCÔ Ø"�4—?‘? 3¨Ð>¨tÒ>°vÑ>Ð>á™FÜ×#Ñ# DÓ)ˆAÙÜ& s¨D°!Ô4Ø&”w˜s A“Ó(Ð(ð	.Ø�3—9‘9˜TÑ7¨Ð7°Ñ7Ð7øÜò 	.Ù˜Ð-˜dÒ- fÑ-Ò-ð	.ús   ÂB ÂB3Â2B3c                ó&   — | j                  d¬«      S )zŠ
        Compute aggregation in the case of a list-like argument.

        Returns
        -------
        Result of aggregation.
        rn   ©r]   )r^   rX   s    rE   rg   zApply.agg_list_like>  ó   € ð ×*Ñ*°5Ð*Ó9Ð9rG   c                ó\  — t        t        t           | j                  «      }| j                  }g }g }|j
                  dk(  r«|D ]¢  }|j                  |j                  d|¬«      }	t        ||	«      r| j                  g| j                  ¢n| j                  }
 t        |	|«      |g|
¢­i |¤Ž}|j                  |«       t        j                  |«      xs |}|j                  |«       Œ¤ ||fS g }t        |«      D ]“  \  }}|j                  |d|j                   dd…|f   ¬«      }	t        ||	«      r| j                  g| j                  ¢n| j                  }
 t        |	|«      |g|
¢­i |¤Ž}|j                  |«       |j                  |«       Œ• |j"                  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.
        r4   )rp   ÚsubsetN)r
   rs   r   rA   r@   rp   rŠ   rŒ   Úinclude_axisrB   r:   rl   Úappendri   rt   Ú	enumerateÚilocÚcolumnsÚtake)rT   r]   Úselected_objr;   rA   r@   r‹   ÚkeysÚarŽ   r:   Únew_resrŒ   Úindicesrz   r~   s                   rE   Úcompute_list_likezApply.compute_list_likeH  s´  € ô4 ”DœÑ)¨4¯9©9Ó5ˆØ�h‰hˆàˆØˆð ×Ñ Ò!Øò "�Ø—|‘| L×$5Ñ$5¸AÀl�|ÓS�ô $ G¨TÔ2ð —Y‘YÐ+ §¡Ñ+àŸ™ð ð
 1œ' $¨Ó0°ÐD°TÒD¸VÑD�Ø—‘˜wÔ'ô ×,Ñ,¨QÓ/Ò4°1�Ø—‘˜DÕ!ð"ð< �Wˆ}Ðð ˆGÜ'¨Ó5ò 	&‘
��sØ—|‘| C¨a¸×8IÑ8IÊ!ÈUÈ(Ñ8S�|ÓT�ô $ G¨TÔ2ð —Y‘YÐ+ §¡Ñ+àŸ™ð ð
 1œ' $¨Ó0°ÐG¸ÒGÀÑG�Ø—‘˜wÔ'Ø—‘˜uÕ%ð	&ð  ×'Ñ'×,Ñ,¨WÓ5ˆDà�Wˆ}ÐrG   c                óÔ   — ddl m} | j                  }	  |||dd¬«      S # t        $ r>}ddlm}  ||||j                  ¬«      }t        |«      rt        d«      |‚|cY d }~S d }~ww xY w)	Nr   r‚   r4   F)r�   rB   Úsort©r.   ©rz   rŒ   z3cannot combine transform and aggregation operations)	r†   rƒ   r@   rw   Úpandasr.   rŒ   r   rS   )rT   r�   r‹   rƒ   r@   r€   r.   r   s           rE   Úwrap_results_list_likezApply.wrap_results_list_likeŠ  so   € õ 	6à�h‰hˆð	Ù˜'¨°1¸5ÔAÐAøÜò 
	õ &á˜G¨4°c·h±hÔ?ˆFÜ Ô'Ü ØIóàðð �Mûð
	ús   ”   	A'©3A"ÁA'Á"A'c                ó&   — | j                  d¬«      S )zŠ
        Compute aggregation in the case of a dict-like argument.

        Returns
        -------
        Result of aggregation.
        rn   r’   )ra   rX   s    rE   rf   zApply.agg_dict_likeŸ  r“   rG   c                óÚ  — ddl m}m} | j                  }t	        |||f«      }t        t        | j                  «      }	| j                  |||	«      }	|j                  dk(  xr0 |j                  j                  «       t        |j                  «      k  }
|j                  dk(  rc|j                  |d¬«      }|	j                  «       D ��cg c]  \  }} t        ||«      |fi |¤Ž‘Œ }}}t!        |	j#                  «       «      }||fS |sô|
ròg }g }|	j                  «       D ]×  \  }}|j                  j%                  |g«      }|j                  j'                  |«      }t)        t         «      }t+        ||«      D ]  \  }}||   j-                  |«       Œ |j                  «       D ���cg c]0  \  }}|D ]&  } t        |j/                  |d¬«      |«      |fi |¤Ž‘Œ( Œ2 }}}}||gt        |«      z  z  }||z  }ŒÙ ||fS |	j                  «       D ��cg c])  \  }} t        |j                  |d¬«      |«      |fi |¤Ž‘Œ+ }}}t!        |	j#                  «       «      }||fS c c}}w c c}}}w c c}}w )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é   r4   r„   r…   )Úpandas.core.groupby.genericr«   r¬   r@   rc   r
   r   rA   rˆ   rp   rš   Únuniquer‡   rŠ   r‰   rl   rs   r�   Úget_indexer_forr›   r   Úzipr—   Ú_ixs)rT   r]   rœ   Ú	selectionr;   r«   r¬   r@   Ú
is_groupbyrA   Úis_non_unique_colrŽ   rD   r�   r‹   r�   Úkeyr    ÚlabelsÚlabel_to_indicesrz   ÚlabelÚindiceÚkey_datas                           rE   Úcompute_dict_likezApply.compute_dict_like©  s“  € ÷:	
ð
 �h‰hˆÜ Ð&6¸Ð%FÓGˆ
Ü”O T§Y¡YÓ/ˆØ×*Ñ*¨7°LÀ$ÓGˆð ×Ñ Ñ"ò KØ×$Ñ$×,Ñ,Ó.´°\×5IÑ5IÓ1JÑJð 	ð
 ×Ñ Ò!à—<‘< 	°�<Ó2ˆDØKOÏ:É:Ë<×XÁÀÀCÐ-”w˜t WÓ-¨cÑ<°VÓ<ÐXˆGÑXÜ˜Ÿ	™	›Ó$ˆDð: �Wˆ}Ðñ9 Ñ 1ð ˆGØˆDØ ŸJ™J›Lò $‘��SØ&×.Ñ.×>Ñ>À¸uÓE�Ø%×-Ñ-×2Ñ2°7Ó;�Ü#.¬tÓ#4Ð Ü$'¨°Ó$8ò :‘L�E˜5Ø$ UÑ+×2Ñ2°5Õ9ð:ð
 +;×*@Ñ*@Ó*B÷ð á&˜˜wØ")òð ð H”G˜L×-Ñ-¨f¸1Ð-Ó=¸wÓGÈÑVÈvÓVðØVð�ò ð ˜˜¤ H£Ñ-Ñ-�Ø˜8Ñ#‘ð$ð. �Wˆ}Ðð	 !%§
¡
£÷á�C˜ð <”˜Ÿ™ S¨q˜Ó1°7Ó;¸CÑJÀ6ÓJðˆGñ ô ˜Ÿ	™	›Ó$ˆDà�Wˆ}Ðùó= Yùôùós   ÃIÆ#5I 
È.I'c                ó¢  — ddl m} ddlm} | j                  }|D �cg c]  }t        |t        «      ‘Œ }}t        |«      r®t        t        ||«      «      }	|D �
cg c]  }
|	|
   j                  rŒ|
‘Œ }}
|g k7  r|n|}|j                  dk(  r/ ||«      }|j                  |j                  j                  «       |}t        |t        «      rdnd} ||D �
ci c]  }
|
|	|
   “Œ
 c}
||¬«      }|S t!        |«      rt#        d«      ‚ddl m} |j                  dk(  rt'        d	|«      }|j(                  }nd } ||||¬
«      }|S c c}w c c}
w c c}
w )Nr   ©r-   r‚   r­   r4   )rB   r�   zLcannot perform both aggregation and transformation operations simultaneouslyr¤   r.   r¥   )r¦   r-   r†   rƒ   r@   rc   r#   ÚallÚdictr±   ry   rp   Ú
_set_namesrš   Únamesr$   ÚanyrS   r.   r
   rŒ   )rT   rœ   Úresult_indexÚresult_datar-   rƒ   r@   ÚrÚ
is_ndframer‹   ÚkÚkeys_to_useÚkturB   r   r.   rŒ   s                    rE   Úwrap_results_dict_likezApply.wrap_results_dict_likeø  sS  € õ 	!Ý5à�h‰hˆð :EÖE°A”j ¤JÕ/ÐEˆ
ÐEäˆzŒ?Üœ3˜|¨[Ó9Ó:ˆGà&2ÖK ¸'À!¹*×:JÓ:Jš1ÐKˆKÐKà)4¸Ò):™+ÀˆKØ× Ñ  AÒ%á˜KÓ(�Ø—‘˜|×3Ñ3×9Ñ9Ô:Ø!�ä!+¨C´Ô!;™AÀˆDÙØ(3Ö4 1��G˜A‘J‘Ò4ØØ ôˆFð2 ˆô) �Œ_äð!óð õ &ð �x‰x˜1Š}Ü˜8 SÓ)�Ø—x‘x‘à�á˜K¨|À$ÔGˆFàˆùòQ Fùò
 Lùò 5s   �EÁEÁ/EÃEc                óp  — t        t        | j                  «      }| j                  }ddlm}m} t        ||d«      }t        |«      rÆt        j                  |«      }g |j                  ¢|j                  ¢­}| j                  dk7  rd|vs|dv rt        d|› d�«      ‚d|v rlt        |||f«      rEd}|dv r| j                  j                  }|| j                  k7  r3| j                  | j                   d<   n| j                  | j                   d<    | j"                  ||g| j                  ¢­i | j                   ¤ŽS )	zy
        Compute apply in case of a string.

        Returns
        -------
        result: Series or DataFrame
        r   rª   NrB   )ÚcorrwithÚskewz
Operation z does not support axis=1)ÚidxmaxÚidxmin)r
   rd   rA   r@   r®   r«   r¬   rl   rh   ÚinspectÚgetfullargspecr:   Ú
kwonlyargsrB   rS   rc   r;   r�   )	rT   rA   r@   r«   r¬   ÚmethodÚsigÚ	arg_namesÚdefault_axiss	            rE   re   zApply.apply_str.  s  € ô ”C˜Ÿ™Ó#ˆà�h‰hˆ÷	
ô ˜˜d DÓ)ˆÜ�FÔÜ×(Ñ(¨Ó0ˆCØ4˜#Ÿ(™(Ð4 S§^¡^Ñ4ˆIØ�y‰y˜AŠ~Ø˜iÑ'¨4Ð3GÑ+Gä  :¨d¨VÐ3KÐ!LÓMÐMØ˜Ñ"Ü˜c MÐ3CÐ#DÔEð
 $%�LØÐ3Ñ3ð (,§x¡x§}¡}˜à# t§y¡yÒ0Ø.2¯i©i˜Ÿ™ FÒ+à*.¯)©)�D—K‘K Ñ'Øˆt�‰˜s DÐD¨4¯9©9ÒD¸¿¹ÑDÐDrG   c                óÚ  — | j                   dk(  rt        d«      ‚| j                  dk(  rlt        | j                  t
        «      rR | j                  j                  j                  | j                  dfd| j                  i| j                  ¤Žj                  S | j                  }| j                  }t        |«      r| j                  d¬«      }n| j                  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.r4   r   r:   rY   r’   )r8   ÚNotImplementedErrorrB   rc   r@   r"   rq   rY   rA   r:   r;   r   ra   r^   Úreconstruct_and_relabel_result)rT   rA   r;   r   s       rE   Úapply_list_or_dict_likezApply.apply_list_or_dict_like]  sË   € ð �;‰;˜'Ò!Ü%ð/óð ð
 �9‰9˜Š>œj¨¯©´<Ô@Ø#�4—8‘8—:‘:×#Ñ# D§I¡I¨qÑP°t·y±yÐPÀDÇKÁKÑP×RÑRÐRà�y‰yˆØ—‘ˆä˜ÔØ×0Ñ0¸Ð0ÓA‰Fà×0Ñ0¸Ð0ÓAˆFä/°¸ÑGÀÑGˆàˆrG   c                óŒ  ‡	— |dv sJ ‚|dk(  r0t        |t        «      r t        d„ |j                  «       D «       «      s t        d„ |j                  «       D «       «      rt	        d«      ‚|j
                  dk7  rfddlm}  |t        |j                  «       «      «      j                  |j                  d	¬
«      }t        |«      dkD  rt        dt        |«      › d�«      ‚t        t        t        fŠ	t        ˆ	fd„|j                  «       D «       «      r4i }|j                  «       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   rn   rr   rn   c              3  ó8   K  — | ]  \  }}t        |«      –— Œ y ­wrW   )r   ©Ú.0rD   r}   s      rE   ú	<genexpr>z/Apply.normalize_dictlike_arg.<locals>.<genexpr>Œ  s   è ø€ Ò=©¨¨1”L —OÑ=ùó   ‚c              3  ó8   K  — | ]  \  }}t        |«      –— Œ y ­wrW   )r   rß   s      rE   rá   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>�  s   è ø€ Ò;¡d a¨”,˜q—/Ñ;ùrâ   znested renamer is not supportedr4   r   r¾   T)r£   z
Column(s) z do not existc              3  ó<   •K  — | ]  \  }}t        |‰«      –— Œ y ­wrW   )rc   )rà   rD   ÚxÚaggregator_typess      €rE   rá   z/Apply.normalize_dictlike_arg.<locals>.<genexpr>Ÿ  s   øè ø€ ÒH±4°1°aŒz˜!Ð-×.ÑHùs   ƒ)rc   r$   rÃ   r‰   r   rp   r¦   r-   rs   r�   Ú
differencerš   r‡   ÚKeyErrorÚtuplerÀ   )
rT   r�   r@   rA   r-   ÚcolsÚnew_funcrÈ   r}   ræ   s
            @rE   rˆ   zApply.normalize_dictlike_arg|  s!  ø€ ð Ð3Ñ3Ð3Ð3ð �5ŠLÜ˜3¤	Ô*ÜÑ=°·
±
³Ô=Ô=ÜÑ;¨d¯j©j«lÔ;Ô;ä$Ð%FÓGÐGà�8‰8�qŠ=å$áœ˜dŸi™i›kÓ*Ó+×6Ñ6°s·{±{ÈÐ6ÓNˆDÜ�4‹y˜1Š}Ü ¬D°«J¨<°}ÐEÓFÐFä ¤%¬Ð.Ðô ÓH¸4¿:¹:»<ÔHÔHØ(*ˆHØŸ
™
›ò $‘��1Ü! !Ð%5Ô6Ø#$ #�H˜Q’Kà"#�H˜Q’Kð	$ð
 ˆDØˆrG   c                ó®  — t        |t        «      sJ ‚t        ||«      rTt        ||«      }t	        |«      r ||i |¤ŽS t        |«      dk(  sJ ‚t        |D �cg c]	  }|dvsŒ|‘Œ c}«      dk(  sJ ‚|S t        t        |«      r(t        |d«      rt        t        |«      } ||g|¢­i |¤ŽS d|› dt        |«      j                  › d�}t        |«      ‚c c}w )z®
        if arg is a string, then try to operate on it:
        - try to find a function (or attribute) on obj
        - try to find a numpy function
        - raise
        r   r…   Ú	__array__ú'z' is not a valid function for 'z' object)
rc   rd   Úhasattrrl   rh   r‡   ÚnpÚtypeÚ__name__ÚAttributeError)rT   r@   rA   r:   r;   rm   ÚkwargÚmsgs           rE   r�   zApply._apply_str©  sã   € ô ˜$¤Ô$Ð$Ð$ä�3˜ÔÜ˜˜TÓ"ˆAÜ˜Œ{Ù˜$Ð) &Ñ)Ð)ô �t“9 ’>Ð!�>Ü¨6ÖK %°UÀ(Ò5JšÒKÓLÐPQÒQÐQÐQØˆHÜ”R˜Ô¤7¨3°Ô#<äœ˜DÓ!ˆAÙ�SÐ*˜4Ò* 6Ñ*Ð*à�d�VÐ:¼4À»9×;MÑ;MÐ:NÈhÐWˆCÜ  Ó%Ð%ùò Ls   Á	CÁ!C)r@   r   rA   r   r5   Úboolr6   ú
str | Noner7   ú#Literal[False, 'compat', '_compat']r8   rd   r9   údict[str, bool] | NoneÚreturnÚNone©rú   úDataFrame | Series©r]   úLiteral['agg', 'apply']rú   rý   )rú   zDataFrame | Series | None)rú   r,   )r]   rÿ   rœ   úSeries | DataFramer;   údict[str, Any]rú   z(tuple[list[Hashable] | Index, list[Any]])r�   úIterable[Hashable]r‹   zlist[Series | DataFrame])
r]   rÿ   rœ   r   r³   zHashable | Sequence[Hashable]r;   r  rú   z tuple[list[Hashable], list[Any]])rœ   r   rÄ   zlist[Hashable]rÅ   rs   )r�   rd   r@   rý   rA   r   rú   r   )rA   rd   )rò   Ú
__module__Ú__qualname__Ú__annotations__rU   ÚabcÚabstractmethodrY   r^   ra   rn   rr   ru   rv   rg   r¡   r§   rf   r¼   rË   re   rÜ   rˆ   r�   rO   rG   rE   rI   rI   v   sÐ  … Ø
ƒMð 7?ØØ04ñ!àð!ð ð!ð ð	!ð
  ð!ð 4ð!ð ð!ð .ð!ð 
ó!ðF 	×Ñòó ðð 	×ÑðØ.ðà	òó ðð
 	×ÑðØ.ðà	òó ðó
ó@AóF'ó0.ó.:ð@à(ð@ð )ð@ð ð	@ð
 
2ó@ðDØ&ðØ1Ióó*:ðMà(ðMð )ðMð 1ð	Mð
 ðMð 
*óMð^4à(ð4ð %ð4ð ó	4ól-Eó^ð>+Øð+Ø/ð+Ø7Fð+à	ó+ôZ&rG   rI   )Ú	metaclassc                  ó`   — e Zd ZU dZded<   ed	d„«       Zed	d„«       Z	 	 	 	 d
d„Z	 	 	 	 d
d„Z	y)ÚNDFrameApplyzg
    Methods shared by FrameApply and SeriesApply but
    not GroupByApply or ResamplerWindowApply
    rý   r@   c                ó.   — | j                   j                  S rW   )r@   rz   rX   s    rE   rz   zNDFrameApply.indexÍ  s   € à�x‰x�~‰~ÐrG   c                óL   — | j                   j                  | j                  «      S rW   )r@   Ú_get_agg_axisrB   rX   s    rE   Úagg_axiszNDFrameApply.agg_axisÑ  s   € à�x‰x×%Ñ% d§i¡iÓ0Ð0rG   c                óV  — | 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«      ‚| j                  |||«      \  }}| j                  ||«      }|S )	NrY   rN   Fr7   rB   r   r4   ú"axis other than 0 is not supported)
r@   r;   rc   r2   r7   ÚSeriesApplyrl   rÚ   r¡   r§   )rT   r]   r@   r;   r7   r�   r‹   r   s           rE   r^   z#NDFrameApply.agg_or_apply_list_likeÕ  sª   € ð �h‰hˆØ—‘ˆà�gÒÜ˜$¤
Ô+ØŸ™‘ä˜D¤+Ô.Ø&*§k¢k™°u‘à�Ø1˜Ð1 ¨&Ñ1ˆFä�3˜ Ó" aÒ'Ü%Ð&JÓKÐKà×.Ñ.¨w¸¸VÓD‰ˆˆgØ×,Ñ,¨T°7Ó;ˆØˆrG   c                ó  — |dv sJ ‚| j                   }i }|dk(  r#| j                  rdnd}|j                  d|i«       t        |dd«      dk(  rt	        d	«      ‚d }| j                  ||||«      \  }}| j                  |||«      }|S )
N©rn   rY   rY   rN   Fr7   rB   r   r4   r  )r@   r7   Úupdaterl   rÚ   r¼   rË   )	rT   r]   r@   r;   r7   r³   rÄ   rÅ   r   s	            rE   ra   z#NDFrameApply.agg_or_apply_dict_likeì  s¢   € ð Ð*Ñ*Ð*Ð*Ø�h‰hˆàˆØ�gÒØ"&§+¢+‘Y°5ˆFØ�M‰M˜8 VÐ,Ô-ä�3˜ Ó" aÒ'Ü%Ð&JÓKÐKàˆ	Ø$(×$:Ñ$:Ø�S˜) Vó%
Ñ!ˆ�kð ×,Ñ,¨S°,ÀÓLˆØˆrG   N©rú   r-   rþ   )
rò   r  r  Ú__doc__r  Úpropertyrz   r  r^   ra   rO   rG   rE   r
  r
  Å  s_   … ñð
 
Óàòó ðð ò1ó ð1ðØ.ðà	óð.Ø.ðà	ôrG   r
  c                  ó  ‡ — e Zd ZU ded<   d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ej                  ej                  	 d	 d d„«       «       «       Zej                  d„ «       Z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#d„Zd$d„Zd„ Zd%d„Zd„ Zd!d„Zd"ˆ fd„Zˆ xZ S )&r2   r,   r@   FrK   NrL   c               óf   •— |dur|dk7  rt        d|› d�«      ‚t        ‰
| �	  |||||||||	¬«	       y )NFrJ   zby_row=z not allowed)r7   r8   r9   r:   r;   )rS   ÚsuperrU   )rT   r@   rA   r5   r6   r7   r8   r9   r:   r;   Ú	__class__s             €rE   rU   zFrameApply.__init__  sU   ø€ ð ˜Ñ 6¨XÒ#5Ü˜w v h¨lÐ;Ó<Ð<Ü‰ÑØØØØØØØ'ØØð 	õ 
	
rG   c                 ó   — y rW   rO   rX   s    rE   rÄ   zFrameApply.result_index#  ó   € ð 	rG   c                 ó   — y rW   rO   rX   s    rE   Úresult_columnszFrameApply.result_columns(  r  rG   c                 ó   — y rW   rO   rX   s    rE   Úseries_generatorzFrameApply.series_generator-  r  rG   c                 ó   — y rW   rO   )rA   ÚnogilÚnopythonÚparallels       rE   Úgenerate_numba_apply_funcz$FrameApply.generate_numba_apply_func2  s   € ð 	rG   c                 ó   — y rW   rO   rX   s    rE   Úapply_with_numbazFrameApply.apply_with_numba:  rZ   rG   c                óÊ   — | j                   j                  j                  «       D ]<  \  }}t        |«      st	        d|› d|› d�«      ‚t        |«      sŒ/t	        d|› d�«      ‚ y )NzColumn z# must have a numeric dtype. Found 'z	' insteadzM is backed by an extension array, which is not supported by the numba engine.)r@   Údtypesr‰   r   rS   r   )rT   ÚcolnameÚdtypes      rE   Úvalidate_values_for_numbaz$FrameApply.validate_values_for_numba>  s}   € à"Ÿh™hŸo™o×3Ñ3Ó5ò 
	‰NˆG�UÜ# EÔ*Ü Ø˜g˜Yð 'Ø#˜W Ið/óð ô (¨Õ.Ü Ø˜g˜Yð 'Bð Cóð ñ
	rG   c                 ó   — y rW   rO   ©rT   r‹   Ú	res_indexs      rE   Úwrap_results_for_axisz FrameApply.wrap_results_for_axisL  r_   rG   c                ó   — | j                   S rW   )r  rX   s    rE   Úres_columnszFrameApply.res_columnsT  s   € à×"Ñ"Ð"rG   c                ó.   — | j                   j                  S rW   )r@   rš   rX   s    rE   rš   zFrameApply.columnsX  s   € à�x‰x×ÑÐrG   c                ó.   — | j                   j                  S rW   )r@   ÚvaluesrX   s    rE   r6  zFrameApply.values\  s   € à�x‰x�‰ÐrG   c                óv  — t        | j                  «      r*| j                  dk(  rt        d«      ‚| j	                  «       S t        | j                  «      dk(  r(t        | j                  «      dk(  r| j                  «       S t        | j                  t        «      r*| j                  dk(  rt        d«      ‚| j                  «       S t        | j                  t        j                  «      r‘| j                  dk(  rt        d«      ‚t        j                  d¬«      5  | j                  j                   j#                  d| j                  ¬	«      }d
d
d
«       | j                  j%                  |j&                  ¬«      S | j(                  dk(  r5| j                  dk(  rt        d«      ‚| j+                  | j                  «      S t-        | j                  j.                  «      s| j                  «       S | j0                  r'| j3                  | j                  | j4                  ¬«      S | j7                  «       S # 1 sw Y   ŒæxY w)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¿   rY   )rA   N)ÚaxesrQ   z:the 'numba' engine doesn't support result_type='broadcast'©r8   r9   )r   rA   r8   rÚ   rÜ   r‡   rš   rz   Úapply_empty_resultrc   rd   re   rð   ÚufuncÚerrstater@   Ú_mgrrY   Ú_constructor_from_mgrr:  r6   Úapply_broadcastr¿   Úshaper5   Ú	apply_rawr9   Úapply_standard©rT   r‹   s     rE   rY   zFrameApply.apply`  sß  € ô ˜Ÿ	™	Ô"Ø�{‰{˜gÒ%Ü)ØOóð ð ×/Ñ/Ó1Ð1ô ˆt�|‰|Ó Ò!¤c¨$¯*©*£o¸Ò&:Ø×*Ñ*Ó,Ð,ô �d—i‘i¤Ô%Ø�{‰{˜gÒ%Ü)ð8óð ð —>‘>Ó#Ð#ô ˜Ÿ	™	¤2§8¡8Ô,Ø�{‰{˜gÒ%Ü)ðCóð ô —‘ Ô*ñ GØŸ(™(Ÿ-™-×-Ñ-¨g¸D¿I¹IÐ-ÓF�÷Gð —8‘8×1Ñ1°'ÀÇÁÐ1ÓMÐMð ×Ñ˜{Ò*Ø�{‰{˜gÒ%Ü)ØPóð ð ×'Ñ'¨¯©Ó1Ð1ô �T—X‘X—^‘^Ô$Ø×*Ñ*Ó,Ð,ð �XŠXØ—>‘>¨¯©ÀD×DVÑDV�>ÓWÐWà×"Ñ"Ó$Ð$÷+Gð Gús   Ä2H/È/H8c                óÀ  •— | j                   }| j                  }| j                  dk(  r| j                   n| j                   j                  | _         d| _        d }	 t        ‰| �  «       }|| _         || _        |dk(  r|�|j                  n|}|€> | j                   j
                  | j                  |fd| j                  i| j                  ¤Ž}|S # || _         || _        w xY w)Nr   r4   r:   )	r@   rB   rq   r  rn   rY   rA   r:   r;   )rT   r@   rB   r   r  s       €rE   rn   zFrameApply.agg–  s¿   ø€ Ø�h‰hˆØ�y‰yˆð  $Ÿy™y¨Aš~�4—8’8°4·8±8·:±:ˆŒØˆŒ	àˆð	Ü‘W‘[“]ˆFàˆDŒHØˆDŒIà�1Š9Ø!'Ð!3�V—X’X¸ˆFàˆ>Ø#�T—X‘X—^‘^ D§I¡I¨tÑS¸$¿)¹)ÐSÀtÇ{Á{ÑSˆFàˆøð ˆDŒHØˆD�Iús   ÁC ÃCc                ón  — t        | j                  «      sJ ‚| j                  dvr| j                  j	                  «       S | j                  dk(  }ddlm} |s¨	 | j                  dk(  rA | j                   |g t        j                  ¬«      g| j                  ¢­i | j                  ¤Ž}nJ | j                   || j                  t        j                  ¬«      g| j                  ¢­i | j                  ¤Ž}t        ||«       }|r�t        | j                   «      rA | j                   |g t        j                  ¬«      g| j                  ¢­i | j                  ¤Ž}nt        j"                  }| j                  j%                  || j                   ¬«      S | j                  j	                  «       S # t        $ r Y Œ´w xY w)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
        )rP   NrP   r   r¤   ©r,  )rz   r,  ©rz   )rh   rA   r6   r@   Úcopyr¦   r.   rB   rð   Úfloat64r:   r;   rš   rc   rx   r‡   r  ÚnanÚ_constructor_sliced)rT   Úshould_reducer.   rÆ   s       rE   r<  zFrameApply.apply_empty_result­  sk  € ô ˜Ÿ	™	Ô"Ð"Ð"ð ×ÑÐ#3Ñ3Ø—8‘8—=‘=“?Ð"ð ×(Ñ(¨HÑ4ˆå!áð:Ø—9‘9 ’>Ø!˜Ÿ	™	Ù˜r¬¯©Ô4ðØ7;·y±yòØDHÇKÁKñ‘Að "˜Ÿ	™	Ù T§\¡\¼¿¹ÔDðàŸ™òð Ÿ+™+ñ�Aô %/¨q°&Ó$9Ð 9�áÜ�4—=‘=Ô!Ø�D—I‘I™f R¬r¯z©zÔ:ÐV¸T¿Y¹YÒVÈ$Ï+É+ÑV‘ä—F‘F�à—8‘8×/Ñ/°¸¿¹Ð/ÓGÐGà—8‘8—=‘=“?Ð"øô ò Ùðús   ÁBF( Æ(	F4Æ3F4c                ó&  — d„ }|dk(  rO|€i n|}t        | j                  fi |¤Ž} || j                  | j                  «      }t	        j
                  |«      }nSt	        j                   || j                  «      | j                  | j                  g| j                  ¢­i | j                  ¤Ž}|j                  dk(  r2| j                  j                  || j                  | j                  ¬«      S | j                  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                 ón   •—  ‰| i |¤Ž}t        |t        «      rt        j                  |t        ¬«      }|S )NrH  )rc   rd   rð   ÚarrayÚobject)r:   r;   r   rA   s      €rE   Úwrapperz<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapperå  s1   ø€ Ù˜tÐ. vÑ.�Ü˜f¤cÔ*ÜŸX™X f´FÔ;�FØ�rG   rO   )rA   rT  s   ` rE   Úwrap_functionz+FrameApply.apply_raw.<locals>.wrap_functionÞ  s   ø€ ôð ˆNrG   rÙ   r­   ©rz   rš   rI  )r%   rA   r6  rB   rð   ÚsqueezeÚapply_along_axisr:   r;   rp   r@   Ú_constructorrz   rš   rM  r  )rT   r8   r9   rU  Ú	nb_looperr   s         rE   rC  zFrameApply.apply_rawÛ  sò   € ò	ð �WÒØ"/Ð"7™B¸]ˆMô .Ø—	‘	ñØ*ñˆIñ ˜tŸ{™{¨D¯I©IÓ6ˆFä—Z‘Z Ó'‰Fä×(Ñ(Ù˜dŸi™iÓ(Ø—	‘	Ø—‘ðð —‘ò	ð
 —+‘+ñˆFð �;‰;˜!ÒØ—8‘8×(Ñ(¨°t·z±zÈ4Ï<É<Ð(ÓXÐXà—8‘8×/Ñ/°¸d¿m¹mÐ/ÓLÐLrG   c                ó4  — t        | j                  «      sJ ‚t        j                  |j                  «      }|j
                  d   }t        |j                  «      D ]ˆ  \  }} | j                  ||   g| j                  ¢­i | j                  ¤Ž}t        j                  |«      j                  }|dkD  rt        d«      ‚|dk(  r|t        |«      k7  rt        d«      ‚||d d …|f<   ŒŠ | j                  j                  ||j                   |j                  ¬«      }|S )Nr   r4   ztoo many dims to broadcastzcannot broadcast resultrV  )rh   rA   rð   Ú
empty_liker6  rB  r˜   rš   r:   r;   Úasarrayrp   rS   r‡   r@   rY  rz   )	rT   ÚtargetÚresult_valuesÚresult_compareÚir~   ÚresÚaresr   s	            rE   rA  zFrameApply.apply_broadcast	  sý   € Ü˜Ÿ	™	Ô"Ð"Ð"äŸ™ f§m¡mÓ4ˆð  Ÿ™ a™ˆä §¡Ó/ò 	&‰FˆAˆsØ�$—)‘)˜F 3™KÐC¨$¯)©)ÒC°t·{±{ÑCˆCÜ—:‘:˜c“?×'Ñ'ˆDð �aŠxÜ Ð!=Ó>Ð>Ø�qŠyà!¤S¨£XÒ-Ü$Ð%>Ó?Ð?à"%ˆMš!˜Q˜$Òð	&ð —‘×&Ñ&Ø §¡°v·~±~ð 'ó 
ˆð ˆrG   c                ó’   — | j                   dk(  r| j                  «       \  }}n| j                  «       \  }}| j                  ||«      S )NrK   )r8   Úapply_series_generatorÚapply_series_numbaÚwrap_resultsr/  s      rE   rD  zFrameApply.apply_standard%  sI   € Ø�;‰;˜(Ò"Ø!%×!<Ñ!<Ó!>ÑˆG‘Yà!%×!8Ñ!8Ó!:ÑˆG�Yð × Ñ  ¨)Ó4Ð4rG   c                óŽ  — t        | j                  «      sJ ‚| j                  }| j                  }i }t	        dd «      5  t        |«      D ]^  \  }} | j                  |g| j                  ¢­i | j                  ¤Ž||<   t        ||   t        «      sŒG||   j                  d¬«      ||<   Œ` 	 d d d «       ||fS # 1 sw Y   ||fS xY w)Nzmode.chained_assignmentF)Údeep)rh   rA   r!  rÄ   r   r˜   r:   r;   rc   r$   rJ  )rT   Ú
series_genr0  r‹   ra  r}   s         rE   re  z!FrameApply.apply_series_generator.  sÊ   € Ü˜Ÿ	™	Ô"Ð"Ð"à×*Ñ*ˆ
Ø×%Ñ%ˆ	àˆäÐ5°tÓ<ñ 	=Ü! *Ó-ò =‘��1à&˜TŸY™Y qÐD¨4¯9©9ÒD¸¿¹ÑD�˜‘
Ü˜g a™j¬)Õ4ð ")¨¡§¡°e Ó!<�G˜A’Jñ=÷	=ð ˜	Ð!Ð!÷	=ð ˜	Ð!Ð!ús   ¾AB8ÂB8Â8Cc                ó.  — | j                   j                  dd«      rt        d«      ‚| j                  j                  j
                  r| j                  j
                  st        d«      ‚| j                  «        | j                  «       }|| 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')
r9   ÚgetrÚ   r@   rz   Ú	is_uniquerš   r-  r(  rÄ   rE  s     rE   rf  zFrameApply.apply_series_numbaA  s„   € Ø×Ñ×!Ñ! *¨eÔ4Ü%ØSóð ð �x‰x�~‰~×'Ò'¨t¯|©|×/EÒ/EÜ%ØTóð ð 	×&Ñ&Ô(Ø×'Ñ'Ó)ˆØ˜×)Ñ)Ð)Ð)rG   c                ó  — ddl m} t        |«      dkD  r$d|v r t        |d   «      r| j	                  ||«      S | j
                  j                  }t        |«      dk(  r||u r ||t        j                  ¬«      }n ||«      }||_	        |S )Nr   r¤   rH  )
r¦   r.   r‡   r   r1  r@   rM  rð   rK  rz   )rT   r‹   r0  r.   Úconstructor_slicedr   s         rE   rg  zFrameApply.wrap_resultsN  sƒ   € Ý!ô ˆw‹<˜!Ò  W¡´¸WÀQ¹ZÔ1HØ×-Ñ-¨g°yÓAÐAð "ŸX™X×9Ñ9ÐÜˆw‹<˜1ÒÐ!3°vÑ!=Ù'¨´r·z±zÔB‰Fá'¨Ó0ˆFØ ˆŒàˆrG   c                óÂ   •— | j                   dk(  rB| j                  }|j                  | j                     }|j	                  || j
                  ¬«      S t        ‰| �  «       S )NÚsizerI  )rA   r@   rB  rB   rM  r  r  re   )rT   r@   Úvaluer  s      €rE   re   zFrameApply.apply_strc  sT   ø€ ð �9‰9˜Òà—(‘(ˆCØ—I‘I˜dŸi™iÑ(ˆEØ×*Ñ*¨5¸¿¹Ð*ÓFÐFÜ‰wÑ Ó"Ð"rG   )r@   r   rA   r   r5   rö   r6   r÷   r7   úLiteral[False, 'compat']r8   rd   r9   rù   rú   rû   r  ©rú   zGenerator[Series, None, None]©TTF©rú   z5Callable[[npt.NDArray, Index, Index], dict[int, Any]]©r‹   ÚResTyper0  r-   rú   rý   rü   )rK   N©r^  r,   rú   r,   )rú   ztuple[ResType, Index])!rò   r  r  r  rU   r  r  r  rÄ   r  r!  ÚstaticmethodÚ	functoolsÚcacher&  r(  r-  r1  r3  rš   r   r6  rY   rn   r<  rC  rA  rD  re  rf  rg  re   Ú__classcell__©r  s   @rE   r2   r2     sÍ  ø… Ø	ƒNð ,1ØØ04ñ
àð
ð ð
ð ð	
ð
  ð
ð )ð
ð ð
ð .ð
ð 
õ
ð< Ø×Ñòó ó ðð Ø×Ñòó ó ðð Ø×Ñòó ó ðð Ø‡_�_Ø×Ñà27ðà	>òó ó ó ðð
 	×Ññó ðòð 	×ÑðØðØ+0ðà	òó ðð ò#ó ð#ð ò ó ð ð ñó ðó4%ôlò.,#ó\,Mó\ò85ó"ò&*ó÷*#ñ #rG   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y
)r=   r   r   rB   c                óR   ‡ — ˆ fd„t        t        ‰ j                  «      «      D «       S )Nc              3  óX   •K  — | ]!  }‰j                   j                  |d ¬«      –— Œ# y­w)r4   r…   N)r@   r²   )rà   ra  rT   s     €rE   rá   z1FrameRowApply.series_generator.<locals>.<genexpr>s  s"   øè ø€ ÒK¨Q�—‘—‘˜a a�×(ÑKùs   ƒ'*)Úranger‡   rš   rX   s   `rE   r!  zFrameRowApply.series_generatorq  s   ø€ ãK´%¼¸D¿L¹LÓ8IÓ2JÔKÐKrG   c                ó¬   ‡‡‡— t        d«      }ddlmŠ ddlmŠ |j
                  j                  | «      Š|j                  |||¬«      ˆˆˆfd„«       }|S )NrÙ   r   r¤   ©Úmaybe_cast_str©r#  r$  r%  c           	     ó’   •— i }t        | j                  d   «      D ](  } ‰| d d …|f   | ‰||   «      ¬«      } ‰|«      ||<   Œ* |S )Nr4   r¥   )r‚  rB  )	r6  Ú	col_namesÚdf_indexr‹   ÚjÚserr.   Ú
jitted_udfr…  s	         €€€rE   Ú
numba_funcz;FrameRowApply.generate_numba_apply_func.<locals>.numba_func…  s]   ø€ àˆGÜ˜6Ÿ<™<¨™?Ó+ò -�áØš1˜a˜4‘L¨±~ÀiÐPQÁlÓ7Sô�ñ (¨›_�˜’
ð-ð ˆNrG   ©r   r¦   r.   Úpandas.core._numba.extensionsr…  Ú	extendingÚregister_jitableÚjit©	rA   r#  r$  r%  rÙ   r�  r.   rŒ  r…  s	         @@@rE   r&  z'FrameRowApply.generate_numba_apply_funcu  sX   ú€ ô
 +¨7Ó3ˆÝ!õ 	Aà—_‘_×5Ñ5°dÓ;ˆ
ð 
�‰˜¨¸HˆÓ	Eõ	ó 
Fð	ð ÐrG   c           	     ó  —  | j                   t        t        | j                  «      fi | j                  ¤Ž}ddlm} | j                  j                  }|j                  dk(  r|j                  t        «      }| j                  j                  }|j                  dk(  r|j                  t        «      } ||«      5 } ||«      5 }t         || j                  ||«      «      }d d d «       d d d «       S # 1 sw Y   ŒxY w# 1 sw Y   S xY w)Nr   ©Úset_numba_dataÚstring)r&  r
   r   rA   r9   r�  r–  r@   rz   r,  ÚastyperS  rš   rÀ   r6  ©rT   Únb_funcr–  rz   rš   rb  s         rE   r(  zFrameRowApply.apply_with_numba’  sá   € Ø0�$×0Ñ0Ü”˜4Ÿ9™9Ó%ñ
Ø)-×);Ñ);ñ
ˆõ 	Aà—‘—‘ˆØ�;‰;˜(Ò"Ø—L‘L¤Ó(ˆEà—(‘(×"Ñ"ˆØ�=‰=˜HÒ$Ø—n‘n¤VÓ,ˆGñ ˜EÓ"ð 	= e©^¸GÓ-Dð 	=ÈÜ‘w˜tŸ{™{¨G°UÓ;Ó<ˆC÷	=÷ 	=àˆ
÷	=ð 	=ú÷ 	=àˆ
ús$   Â8	C=ÃC1ÃC=Ã1C:	Ã6C=Ã=Dc                ó   — | j                   S rW   ©rš   rX   s    rE   rÄ   zFrameRowApply.result_index¦  ó   € à�|‰|ÐrG   c                ó   — | j                   S rW   rI  rX   s    rE   r  zFrameRowApply.result_columnsª  ó   € à�z‰zÐrG   c                óÄ  — | j                   dk(  r$| j                  j                  |«      }||_        |S | j                   €Dt	        d„ |j                  «       D «       «      r$| j                  j                  |«      }||_        |S 	 | j                  j                  |¬«      }t        |d   t        «      s<t        |j                  «      t        | j                  «      k(  r| j                  |_        t        |j                  «      t        |«      k(  r||_        |S # t        $ r<}dt        |«      v r)| j                  j                  |«      }||_        |cY d}~S ‚ d}~ww xY w)zreturn the results for the rowsrP   Nc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrW   )rc   rÀ   )rà   rå   s     rE   rá   z6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>¹  s   è ø€ ò .
Ø$%ŒJ�qœ$×ñ.
ùs   ‚©Údataz%All arrays must be of the same lengthr   )r6   r@   rM  rz   r¿   r6  rY  rS   rd   rc   r$   r‡   r3  rš   )rT   r‹   r0  rb  r   r€   s         rE   r1  z#FrameRowApply.wrap_results_for_axis®  s4  € ð
 ×Ñ˜xÒ'à—(‘(×.Ñ.¨wÓ7ˆCØ!ˆCŒIØˆJà×ÑÐ%¬#ñ .
Ø)0¯©Ó)9ô.
ô +
ð
 —(‘(×.Ñ.¨wÓ7ˆCØ!ˆCŒIØˆJð
	Ø—X‘X×*Ñ*°Ð*Ó8ˆFô ˜' !™*¤iÔ0Ü�6—<‘<Ó ¤C¨×(8Ñ(8Ó$9Ò9Ø#×/Ñ/�”äˆv�~‰~Ó¤# i£.Ò0Ø&ˆFŒNàˆøô# ò 	Ø6¼#¸c»(ÑBð —h‘h×2Ñ2°7Ó;�Ø%�”	Ø•
àûð	ús$   ÂD Ä	EÄ#0EÅEÅEÅENrt  ru  rv  ©rú   zdict[int, Any]r  rw  )rò   r  r  rB   r  r  r!  rz  r{  r|  r&  r(  rÄ   r  r1  rO   rG   rE   r=   r=   n  s•   … Ø€Dˆ'ÓàòLó ðLð Ø‡_�_à27ðà	>òó ó ðó6ð( òó ðð òó ðð'Øð'Ø+0ð'à	ô'rG   r=   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 )r>   r4   r   rB   c                óN   •— t         ‰| �  |j                  «      }|j                  S rW   )r  rA  rq   )rT   r^  r   r  s      €rE   rA  z FrameColumnApply.apply_broadcastÛ  s   ø€ Ü‘Ñ(¨¯©Ó2ˆØ�x‰xˆrG   c              #  óž  K  — | j                   }t        |«      }t        |«      dkD  sJ ‚| j                  j	                  dd¬«      }|j
                  }|j                  d   j                  j                  «       }t        |j                  t        «      r;| j                  }t        t        |«      «      D ]  }|j	                  |d¬«      –— Œ y t        || j                  «      D ]d  \  }}||_        |j                  |«       t         j#                  |d|«       |s*t%        |j                  d   «      |j                  d   _        |–— Œf y ­w)Nr   r…   Ú_name)r6  r&   r‡   r@   r²   r?  ÚblocksÚrefsÚhas_referencerc   r,  r!   r‚  r±   rz   Ú
set_valuesrS  Ú__setattr__r   )	rT   r6  r‹  ÚmgrÚis_viewr@   ra  ÚarrrŒ   s	            rE   r!  z!FrameColumnApply.series_generatorß  s  è ø€ à—‘ˆÜ/°Ó7ˆÜ�6‹{˜QŠÐˆð �h‰h�m‰m˜A AˆmÓ&ˆØ�h‰hˆà—*‘*˜Q‘-×$Ñ$×2Ñ2Ó4ˆä�c—i‘i¤Ô0ð —(‘(ˆCÜœ3˜s›8“_ò *�Ø—h‘h˜q q�hÓ)Ó)ñ*ô ! ¨¯©Ó4ò ‘	��Tà�”Ø—‘˜sÔ#Ü×"Ñ" 3¨°Ô6Ùô *9¸¿¹ÀA¹Ó)G�C—J‘J˜q‘MÔ&Ø“	ñùs   ‚EEc                ó¬   ‡‡‡— t        d«      }ddlmŠ ddlmŠ |j
                  j                  | «      Š|j                  |||¬«      ˆˆˆfd„«       }|S )NrÙ   r   r¤   r„  r†  c           	     ó¦   •— i }t        | j                  d   «      D ]2  } ‰| |   j                  «       | ‰||   «      ¬«      } ‰|«      ||<   Œ4 |S )Nr   r¥   )r‚  rB  rJ  )	r6  Úcol_names_indexrz   r‹   ra  r‹  r.   rŒ  r…  s	         €€€rE   r�  z>FrameColumnApply.generate_numba_apply_func.<locals>.numba_func  se   ø€ àˆGô ˜6Ÿ<™<¨™?Ó+ò -�ñ Ø˜1‘I—N‘NÓ$Ø)Ù'¨¨a©Ó1ô�ñ
 (¨›_�˜’
ð-ð ˆNrG   rŽ  r“  s	         @@@rE   r&  z*FrameColumnApply.generate_numba_apply_func  sS   ú€ ô
 +¨7Ó3ˆÝ!Ý@à—_‘_×5Ñ5°dÓ;ˆ
à	�‰˜¨¸HˆÓ	Eõ	ó 
Fð	ð  ÐrG   c           	     óh  —  | j                   t        t        | j                  «      fi | j                  ¤Ž}ddlm}  || j                  j                  «      5 } || j                  «      5 }t         || j                  ||«      «      }d d d «       d d d «       S # 1 sw Y   ŒxY w# 1 sw Y   S xY w)Nr   r•  )r&  r
   r   rA   r9   r�  r–  r@   rz   rš   rÀ   r6  r™  s         rE   r(  z!FrameColumnApply.apply_with_numba!  s¥   € Ø0�$×0Ñ0Ü”˜4Ÿ9™9Ó%ñ
Ø)-×);Ñ);ñ
ˆõ 	Añ ˜DŸH™HŸN™NÓ+ð 	=¨u±nØ�L‰Ló7
ð 	=àÜ‘w˜tŸ{™{¨G°UÓ;Ó<ˆC÷	=÷ 	=ð
 ˆ
÷	=ð 	=ú÷ 	=ð
 ˆ
ús$   ÁB'Á+BÂ	B'ÂB$	Â B'Â'B1c                ó   — | j                   S rW   rI  rX   s    rE   rÄ   zFrameColumnApply.result_index1  rŸ  rG   c                ó   — | j                   S rW   rœ  rX   s    rE   r  zFrameColumnApply.result_columns5  r�  rG   c                óÞ   — | j                   dk(  r| j                  ||«      }|S t        |d   t        «      s$| j                  j                  |«      }||_        |S | j                  ||«      }|S )z"return the results for the columnsrR   r   )r6   Úinfer_to_same_shaperc   r$   r@   rM  rz   ©rT   r‹   r0  r   s       rE   r1  z&FrameColumnApply.wrap_results_for_axis9  sv   € ð ×Ñ˜xÒ'Ø×-Ñ-¨g°yÓAˆFð ˆô ˜G A™J¬	Ô2Ø—X‘X×1Ñ1°'Ó:ˆFØ$ˆFŒLð ˆð ×-Ñ-¨g°yÓAˆFàˆrG   c                óˆ   — | j                   j                  |¬«      }|j                  }||_        |j	                  d¬«      }|S )z7infer the results to the same shape as the input objectr¢  F©rJ  )r@   rY  rq   rz   Úinfer_objectsr¹  s       rE   r¸  z$FrameColumnApply.infer_to_same_shapeN  sE   € à—‘×&Ñ&¨GÐ&Ó4ˆØ—‘ˆð !ˆŒð ×%Ñ%¨5Ð%Ó1ˆàˆrG   ry  rt  ru  rv  r¤  r  rw  )r‹   rx  r0  r-   rú   r,   )rò   r  r  rB   r  rA  r  r!  rz  r{  r|  r&  r(  rÄ   r  r1  r¸  r}  r~  s   @rE   r>   r>   Ø  s¡   ø… Ø€Dˆ'Óõð ò!ó ð!ðF Ø‡_�_à27ðà	>òó ó ðó8ð  òó ðð òó ððØðØ+0ðà	ó÷*rG   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   rB   rø   r7   rJ   )Úconvert_dtyper7   c          	     ó²   •— |t         j                  u rd}n$t        j                  dt        t        «       ¬«       || _        t        ‰| �!  ||dd |||¬«       y )NTz¢the convert_dtype parameter is deprecated and will be removed in a future version.  Do ``ser.astype(object).apply()`` instead if you want ``convert_dtype=False``.©Ú
stacklevelF)r5   r6   r7   r:   r;   )	r   Ú
no_defaultÚwarningsÚwarnÚFutureWarningr   r¾  r  rU   )rT   r@   rA   r¾  r7   r:   r;   r  s          €rE   rU   zSeriesApply.__init__a  sc   ø€ ð œCŸN™NÑ*Ø ‰Mä�M‰Mð?ô Ü+Ó-õð +ˆÔä‰ÑØØØØØØØð 	õ 	
rG   c                óR  — | j                   }t        |«      dk(  r| j                  «       S t        | j                  «      r| j                  «       S t        | j                  t        «      r| j                  «       S | j                  dk(  r| j                  «       S | j                  «       S )Nr   rN   )r@   r‡   r<  r   rA   rÜ   rc   rd   re   r7   Úapply_compatrD  ©rT   r@   s     rE   rY   zSeriesApply.apply�  s‰   € Ø�h‰hˆäˆs‹8�qŠ=Ø×*Ñ*Ó,Ð,ô ˜Ÿ	™	Ô"Ø×/Ñ/Ó1Ð1ä�d—i‘i¤Ô%à—>‘>Ó#Ð#à�;‰;˜)Ò#Ø×$Ñ$Ó&Ð&ð ×"Ñ"Ó$Ð$rG   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        «       ¬«       |S |S # t        t        t         f$ r$  ||g| j                  ¢­i | j                  ¤Ž}Y |S w xY w)Nr:   zusing z in z3.agg cannot aggregate and has been deprecated. Use z&.transform to keep behavior unchanged.rÀ  )r  rn   r@   rA   rh   rY   r:   r;   rñ   rò   rÃ  rÄ  rÅ  r   rS   ró   rw   )rT   r   r@   rA   rõ   r  s        €rE   rn   zSeriesApply.agg•  sò   ø€ Ü‘‘“ˆØˆ>Ø—(‘(ˆCØ—9‘9ˆDä˜D”>Ð!�>ð

QØ"˜Ÿ™ 4ÑG¨d¯i©iÐG¸4¿;¹;ÑG�ð
 ˜T˜F $¤t¨C£y×'9Ñ'9Ð&:ð ;0Ü04°S³	×0BÑ0BÐ/Cð D/ð0ð ô
 —‘˜c¤=Ô=MÓ=OÕPàˆˆvˆøô ¤´	Ð:ò >Ù˜cÐ= D§I¡IÒ=°·±Ñ=‘ð ˆð>ús   ¸)B; Â;4C3Ã2C3c                óŠ   — | j                   }|j                  |j                  |j                  ¬«      j	                  |d¬«      S )N)r,  rz   rY   ©rÔ   )r@   rY  r,  rz   Ú__finalize__rÈ  s     rE   r<  zSeriesApply.apply_empty_result®  sA   € Ø�h‰hˆØ×Ñ c§i¡i°s·y±yÐÓA×NÑNØ˜ð Oó 
ð 	
rG   c                óT  — | j                   }| j                  }t        |«      rBt        j                  |«      }|r+| j
                  s| j                  s|j                  |d¬«      S 	 |j                  |d¬«      }|S # t        t        t        f$ r |j                  |d¬«      }Y |S w xY w)zõcompat apply method for funcs in listlikes and dictlikes.

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

        .. versionadded:: 2.1.0
        F)r7   rJ   )r@   rA   rh   ri   rj   r:   r;   rY   rS   ró   rw   )rT   r@   rA   rm   r   s        rE   rÇ  zSeriesApply.apply_compat´  sœ   € ð �h‰hˆØ�y‰yˆä�DŒ>Ü×#Ñ# DÓ)ˆAÙ˜Ÿš¨4¯;ª;Ø—y‘y ¨e�yÓ4Ð4ð	3Ø—Y‘Y˜t¨H�YÓ5ˆFð ˆøô œN¬IÐ6ò 	3Ø—Y‘Y˜t¨E�YÓ2‰FØˆð	3ús   Á'A< Á<'B'Â&B'c                ó  ‡ ‡— t        t        ‰ j                  «      Š‰ j                  }t	        ‰t
        j                  «      r@t        j                  d¬«      5   ‰|g‰ j                  ¢­i ‰ j                  ¤Žcd d d «       S ‰ j                  s  ‰|g‰ j                  ¢­i ‰ j                  ¤ŽS ‰ j                  s‰ j                  rˆˆ fd„}n‰}t	        |j                  t        «      rdnd }|j                  ||‰ j                  ¬«      }t        |«      r9t	        |d   t         «      r&|j#                  t%        |«      |j&                  ¬«      S |j)                  ||j&                  ¬«      j+                  |d¬«      S # 1 sw Y   ŒØxY w)	Nr8  r9  c                óD   •—  ‰| g‰j                   ¢­i ‰j                  ¤ŽS rW   )r:   r;   )rå   rA   rT   s    €€rE   Úcurriedz+SeriesApply.apply_standard.<locals>.curried×  s    ø€ Ù˜AÐ9 §	¡	Ò9¨T¯[©[Ñ9Ð9rG   )ÚmapperÚ	na_actionÚconvertr   rI  rY   rË  )r
   r   rA   r@   rc   rð   r=  r>  r:   r;   r7   r,  r    Ú_map_valuesr¾  r‡   r$   Ú_constructor_expanddimrs   rz   rY  rÌ  )rT   r@   rÐ  ÚactionÚmappedrA   s   `    @rE   rD  zSeriesApply.apply_standardÊ  sF  ù€ ä”H˜dŸi™iÓ(ˆØ�h‰hˆä�dœBŸH™HÔ%Ü—‘ Ô*ñ <Ù˜CÐ; $§)¡)Ò;¨t¯{©{Ñ;÷<ñ <à—’Ù˜Ð7˜dŸi™iÒ7¨4¯;©;Ñ7Ð7à�9Š9˜Ÿšö:ð ˆGô (¨¯	©	Ô3CÔD‘È$ˆØ—‘Ø f°d×6HÑ6Hð !ó 
ˆô ˆvŒ;œ: f¨Q¡i´Ô;ð ×-Ñ-¬d°6«lÀ#Ç)Á)Ð-ÓLÐLà×#Ñ# F°#·)±)Ð#Ó<×IÑIØ˜Gð Jó ð ÷9<ð <ús   Á E>Å>F)
r@   r.   rA   r   r¾  zbool | lib.NoDefaultr7   rø   rú   rû   rü   )rú   r.   )rò   r  r  r  rB   r   rÂ  rU   rY   rn   r<  rÇ  rD  r}  r~  s   @rE   r  r  \  ss   ø… Ø	ƒKØ€Dˆ'ÓØ/Ó/ð /2¯n©nØ6>ñ
àð
ð ð
ð
 ,ð
ð 4ð
ð 
õ
ó@%ô(ó2
ò÷,$rG   r  c                  ód   ‡ — 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@   c               ó°   •— |j                  «       }|j                  j                  |j                  dd«      «      | _        t
        ‰| �  ||dd ||¬«       y )NrB   r   F©r5   r6   r:   r;   )rJ  r@   r<   rl  rB   r  rU   ©rT   r@   rA   r:   r;   r  s        €rE   rU   zGroupByApply.__init__ô  sU   ø€ ð —‘“ˆØ—G‘G×,Ñ,¨V¯Z©Z¸ÀÓ-BÓCˆŒ	Ü‰ÑØØØØØØð 	õ 	
rG   c                ó   — t         ‚rW   ©rÚ   rX   s    rE   rY   zGroupByApply.apply  ó   € Ü!Ð!rG   c                ó   — t         ‚rW   rÞ  rX   s    rE   rr   zGroupByApply.transform
  rß  rG   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  | j                  |||«      \  }}d d d «       | j                  «      }|S # 1 sw Y   ŒxY w)NrY   r7   FrB   r   r4   r  Úas_indexT©Ú	condition)r@   r;   rl   rÚ   Ú_selected_objrp   Ú_obj_with_exclusionsri   Útemp_setattrrï   r¡   r§   )rT   r]   r@   r;   rœ   r�   r‹   r   s           rE   r^   z#GroupByApply.agg_or_apply_list_like  sâ   € ð �h‰hˆØ—‘ˆØ�gÒØ0˜Ð0 ¨%Ñ0ˆFä�3˜ Ó" aÒ'Ü%Ð&JÓKÐKà×Ñ×!Ñ! QÒ&à×,Ñ,‰Là×3Ñ3ˆLô ×ÑØ�˜T¬W°S¸*Ó-Eô
ñ 	Rð !×2Ñ2°7¸LÈ&ÓQ‰MˆD�'÷	Rð ×,Ñ,¨T°7Ó;ˆØˆ÷	Rð 	Rús   ÂC	Ã	Cc           	     óp  — ddl m}m} |dv sJ ‚| j                  }i }|dk(  r#| j                  rdnd}|j                  d|i«       t        |dd«      d	k(  rt        d
«      ‚|j                  }|j                  }t        |||f«      }	|	rL| j                  j                  dd «      }
| j                  j                  dd «      }|j                  |
|dœ«       t        j                  |ddt        |d«      ¬«      5  | j!                  ||||«      \  }}d d d «       | j#                  |«      }|S # 1 sw Y   ŒxY w)Nr   rª   r  rY   rN   Fr7   rB   r4   r  r8   r9   r;  râ  Trã  )r®   r«   r¬   r@   r7   r  rl   rÚ   rå  Ú
_selectionrc   r;   rl  ri   rç  rï   r¼   rË   )rT   r]   r«   r¬   r@   r;   r7   rœ   r³   r´   r8   r9   rÄ   rÅ   r   s                  rE   ra   z#GroupByApply.agg_or_apply_dict_like'  s;  € ÷	
ð
 Ð*Ñ*Ð*Ð*à�h‰hˆØˆØ�gÒØ"&§+¢+‘Y°5ˆFØ�M‰M˜8 VÐ,Ô-ä�3˜ Ó" aÒ'Ü%Ð&JÓKÐKà×(Ñ(ˆØ—N‘Nˆ	ä Ð&6¸Ð%FÓGˆ
ñ Ø—[‘[—_‘_ X¨tÓ4ˆFØ ŸK™KŸO™O¨O¸TÓBˆMØ�M‰M V¸mÑLÔMä×ÑØ�˜T¬W°S¸*Ó-Eô
ñ 	ð )-×(>Ñ(>Ø˜ y°&ó)Ñ%ˆL˜+÷	ð ×,Ñ,¨\¸<ÈÓUˆØˆ÷	ð 	ús   Ã7D,Ä,D5)r@   zGroupBy[NDFrameT]rA   r   rú   rû   rþ   )
rò   r  r  r  rU   rY   rr   r^   ra   r}  r~  s   @rE   rÙ  rÙ  ñ  s^   ø… Ø	)Ó)ð
àð
ð ð
ð 
õ
ò&"ò"ðØ.ðà	óð4%Ø.ð%à	÷%rG   rÙ  c                  óR   ‡ — 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   rB   úResampler | BaseWindowr@   c               ó8   •— t         t        | �  ||dd ||¬«       y )NFrÛ  )r  rÙ  rU   rÜ  s        €rE   rU   zResamplerWindowApply.__init__S  s+   ø€ ô 	Œl˜DÑ*ØØØØØØð 	+õ 	
rG   c                ó   — t         ‚rW   rÞ  rX   s    rE   rY   zResamplerWindowApply.applyd  rß  rG   c                ó   — t         ‚rW   rÞ  rX   s    rE   rr   zResamplerWindowApply.transformg  rß  rG   )r@   rì  rA   r   rú   rû   )	rò   r  r  rB   r  rU   rY   rr   r}  r~  s   @rE   rë  rë  O  s>   ø… Ø€Dˆ'ÓØ	Óð
à#ð
ð ð
ð 
õ
ò""ö"rG   rë  c                óö   — | du xr t        di |¤Ž}d}d}|sHt        | t        «      r+t        | «      t        t	        | «      «      kD  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).rO   )Úis_multi_agg_with_relabelrc   rs   r‡   Úsetr   rw   Únormalize_keyword_aggregation)rA   r;   Ú
relabelingrš   Úorders        rE   r?   r?   k  s£   € ðN ˜�ÒEÔ";Ñ"E¸fÑ"E€JØ&*€GØ)-€EáÜ�dœDÔ!¤c¨$£i´#´c¸$³i³.Ò&@ô %ðóð ð ˆ<äÐRÓSÐSáô  =Øó 
Ñˆˆg�uð ÐÐÐà�t˜W eÐ+Ð+rG   c                 ób   — t        d„ | j                  «       D «       «      xr t        | «      dkD  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  ó\   K  — | ]$  }t        |t        «      xr t        |«      d k(  –— Œ& y­w)r­   N)rc   ré   r‡   )rà   r}   s     rE   rá   z,is_multi_agg_with_relabel.<locals>.<genexpr>Å  s'   è ø€ ÒM¸Œz˜!œUÓ#Ò3¬¨A«°!©Ó3ÑMùs   ‚*,r   )r¿   r6  r‡   )r;   s    rE   rñ  rñ  °  s-   € ô* ÑM¸V¿]¹]»_ÔMÓMò ÜˆF‹�a‰ðrG   c           
     óþ  — ddl m} t        t        «      }g }t        t	        | j                  «       Ž «      \  }}|D ]C  \  }}||   j                  |«       |j                  |t        j                  |«      xs |f«       ŒE t        |«      }|j                  «       D ��	�cg c]'  \  }}	|	D ]  }|t        j                  |«      xs |f‘Œ Œ) }
}	}}t        |
«      } ||«      j                  |«      }|||fS c c}}	}w )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¾   )Úpandas.core.indexes.baser-   r   rs   r±   r‰   r—   ri   rt   Ú_make_unique_kwarg_listÚget_indexer)r;   r-   Úaggspecrõ  rš   ÚpairsÚcolumnÚaggfuncÚuniquified_orderÚaggfuncsÚaggspec_orderÚuniquified_aggspecÚcol_idx_orders                rE   ró  ró  Ê  s  € õ< /ô
 œ$Ó€GØ€EÜœ#˜vŸ|™|›~Ð.Ó/�N€GˆUà ò J‰ˆ�Ø�‰×Ñ˜wÔ'Ø�‰�fœc×3Ñ3°GÓ<ÒGÀÐHÕIðJô
 /¨uÓ5Ðð !(§¡£÷ð áˆF�HØòð ð 
”×&Ñ& wÓ/Ò:°7Ò;ðØ;ð€Mò ô
 1°Ó?Ðñ Ð,Ó-×9Ñ9Ð:JÓK€MØ�G˜]Ð*Ð*ùôs   Â!,C8c           
     ó´   — t        | «      D ��cg c]<  \  }}| j                  |«      dkD  r!|d   |d   › d| d| j                  |«      › �fn|‘Œ> c}}S c c}}w )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>')]
    r4   r   rD   N)r˜   Úcount)Úseqra  Úpairs      rE   rú  rú    si   € ô ! “~÷áˆAˆtð :=¿¹À4»È1Ò9Lˆˆa‰�T˜!‘W�I˜Q˜s 2 A˜wŸ}™}¨TÓ2Ð3Ð4Ñ5ÐRVÑVóð ùó s   �AAc                ój  — ddl m} t        t        ||«      d„ ¬«      D �cg c]  }|d   ‘Œ	 }}i }d}t	        | t
        «       xr t        | j                  «      dkD  }	|j                  «       D ]¸  \  }
}| |
   j                  «       }|	rd|D �cg c])  }t	        |t        «      st        j                  |«      n|‘Œ+ }} ||j                  «      j                  |«      }|j                  |   }|||t        |«      z    |_        |j!                  |d¬«      ||
<   |t        |«      z   }Œº |S c c}w c c}w )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                ó   — | d   S )Nr4   rO   )Úts    rE   ú<lambda>z relabel_result.<locals>.<lambda>?  s
   € ÀaÈÁd€ rG   )r¶   r4   Fr»  )rù  r-   Úsortedr±   rc   r$   r‡   rš   r‰   Údropnard   ri   rt   rz   rû  r™   Úreindex)r   rA   rš   rõ  r-   r  Úreordered_indexesÚreordered_result_in_dictÚidxÚreorder_maskr~   ÚfunÚsrm   r  s                  rE   Úrelabel_resultr    sC  € õF /ô #¤3 w°Ó#6¹NÔKöØˆˆQ‹ðÐð ð 8:ÐØ
€Cä! &¬)Ó4Ð4ÒP¼¸V¿^¹^Ó9LÈqÑ9P€LØ—J‘J“Lò "‰ˆˆSØ�3‰K×ÑÓ ˆñ, àSVöØNO´
¸1¼cÔ0B”×%Ñ% aÔ(ÈÑIðˆCð ñ " !§'¡'›N×6Ñ6°sÓ;ˆMØ—‘�}Ñ%ˆAð $ C¨#´°C³©.Ð9ˆŒØ()¯	©	°'À¨	Ó(FÐ  Ñ%Ø”C˜“H‰n‰ðE"ðF $Ð#ùòUùò>s   ¡D+Â.D0c                óx   — ddl m} t        |fi |¤Ž\  }}}}|r |€J ‚|€J ‚t        | |||«      } |||¬«      } | S )Nr   )r,   rI  )r¦   r,   r?   r  )r   rA   r;   r,   rô  rš   rõ  Úresult_in_dicts           rE   rÛ   rÛ   k  s[   € Ý ä'7¸Ñ'GÀÑ'GÑ$€J��g˜uáð Ð"Ð"Ð"ØÐ Ð Ð ä'¨°°g¸uÓEˆÙ˜>°Ô9ˆà€MrG   c                óÄ   — t        | «      dk  r| S d}g }| D ]F  }t        j                  |«      dk(  rt        |«      }d|› d�|_        |dz  }|j                  |«       ŒH |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.
    r4   r   z<lambda>z<lambda_ú>)r‡   ri   rt   r   rò   r—   )r  ra  Úmangled_aggfuncsrÿ  s       rE   Ú_managle_lambda_listr  †  s{   € ô$ ˆ8ƒ}˜ÒàˆØ	€AØÐØò )ˆÜ× Ñ  Ó)¨ZÒ7Ü˜gÓ&ˆGØ!)¨!¨¨A˜ˆGÔØ�‰FˆAØ×Ñ Õ(ð)ð ÐrG   c                óú   — t        | «      }|st        | «      s| S  t        | «      «       }|rC| j                  «       D ].  \  }}t        |«      rt        |«      st	        |«      }n|}|||<   Œ0 |S 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  )Úagg_specÚis_dictÚmangled_aggspecr¶   r  r  s         rE   Úmaybe_mangle_lambdasr!  §  sŒ   € ô2 ˜8Ó$€GÙ”| HÔ-ØˆØ$”d˜8“nÓ&€OáØ%Ÿ^™^Ó-ò 	4‰MˆC�Ü˜HÔ%¬l¸8Ô.DÜ#7¸Ó#AÑ à#+Ð à#3ˆO˜CÒ ð	4ð Ðô /¨xÓ8ˆàÐrG   c                ó"  — d}t        | «      }g }| j                  «       D ][  }t        |t        «      s8t	        |«      s-t        |j                  t        |«      j                  «      «      ‚|j                  |«       Œ] |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.)
rs   r6  rc   rd   rh   rw   Úformatrñ   rò   r—   )r;   Útuple_given_messagerš   rA   Úcol_funcÚno_arg_messages         rE   Úvalidate_func_kwargsr'  Ó  s‹   € ð. JÐÜ�6‹l€GØ€DØ—M‘M“Oò ˆÜ˜8¤SÔ)¬X°hÔ-?ÜÐ/×6Ñ6´t¸H³~×7NÑ7NÓOÓPÐPØ�‰�HÕðñ ØMˆÜ˜Ó'Ð'Ø�Dˆ=ÐrG   c                óT   — t        |t        «      xs t        |t        «      xr | dk(  S )Nrn   )rc   r"   r$   )r]   rŽ   s     rE   r–   r–   ÷  s*   € Ü�dœLÓ)ò Ü�4œÓ#Ò8¨°5Ñ(8ðrG   c           	     óÈ   — |j                  d«      r|}n t        | «      j                  › d|› �}d|› d�}t        j                  d|› d|› d|› d�t
        t        «       ¬«       y )	Nznp.ú.ú"zThe provided callable z is currently using zw. In a future version of pandas, the provided callable will be used directly. To keep current behavior pass the string z	 instead.)ÚcategoryrÁ  )Ú
startswithrñ   rò   rÃ  rÄ  rÅ  r   )r@   rA   ÚaliasÚ
full_aliass       rE   rk   rk   ý  sv   € ð
 ×Ñ˜ÔØ‰
ä˜S›	×*Ñ*Ð+¨1¨U¨GÐ4ˆ
Ø�E�7˜!�ˆÜ‡M�MØ
   Ð&:Øˆ,ð $à$) 7¨)ð	5ô Ü#Ó%örG   )r   FNrJ   rK   NNN)r@   r,   rA   r   rB   r   r5   rö   r6   r÷   r7   rs  r8   rd   r9   rù   rú   r2   )rA   zAggFuncType | Nonerú   zMtuple[bool, AggFuncType, tuple[str, ...] | None, npt.NDArray[np.intp] | None])rú   rö   )r;   rÀ   rú   z]tuple[MutableMapping[Hashable, list[AggFuncTypeBase]], tuple[str, ...], npt.NDArray[np.intp]])r  úSequence[tuple[Any, Any]]rú   r0  )
r   rý   rA   zdict[str, list[Callable | str]]rš   r  rõ  zIterable[int]rú   zdict[Hashable, Series]rü   )r  úSequence[Any]rú   r1  )r  r   rú   r   )r;   rÀ   rú   z0tuple[list[str], list[str | Callable[..., Any]]])r]   rÿ   rŽ   r   rú   rö   )r@   r   rA   r   r.  rd   rú   rû   )gÚ
__future__r   r  Úcollectionsr   r{  r   rÑ   Útypingr   r   r   r	   r
   rÃ  Únumpyrð   Úpandas._configr   Úpandas._libsr   Úpandas._libs.internalsr   Úpandas._typingr   r   r   r   r   r   r   r   Úpandas.compat._optionalr   Úpandas.errorsr   Úpandas.util._decoratorsr   Úpandas.util._exceptionsr   Úpandas.core.dtypes.castr   Úpandas.core.dtypes.commonr   r   r   r   r   Úpandas.core.dtypes.dtypesr    r!   Úpandas.core.dtypes.genericr"   r#   r$   Úpandas.core._numba.executorr%   Úpandas.core.commonÚcoreÚcommonri   Úpandas.core.constructionr&   Úcollections.abcr'   r(   r)   r*   r+   r¦   r,   r-   r.   Úpandas.core.groupbyr/   Úpandas.core.resampler0   Úpandas.core.window.rollingr1   rÀ   Úintrx  rF   ÚABCMetarI   r
  r2   r=   r>   r  rÙ  rë  r?   rñ  ró  rú  r  rÛ   r  r!  r'  r–   rk   rO   rG   rE   ú<module>rM     sq  ðÝ "ã 
Ý #Û Ý Û ÷õ ó ã å )å Ý 2÷	÷ 	ó 	õ ?Ý ,Ý 2Ý 4å 4÷õ ÷÷ñ õ >ß  Ð  Ý Cá÷õ ÷ñ õ
 ,Ý.Ý5ð ˆs�Cˆx‰.€ð ØØ"Ø'/ØØ,0Ø	Øð!Ø	ð!à
ð!ð ð!ð 
ð	!ð
 ð!ð %ð!ð ð!ð *ð!ð ó!ôHL	&�c—k‘kõ L	&ô^:�5ô :ôzi#�ô i#ôXg�Jô gôTA�zô AôHR�,ô Rôj[�5ô [ô|"˜<ô "ð8B,Ø
ðB,àRóB,óJð4:+Øð:+ðó:+ðzØ	"ðàóð$O$ØðO$à
)ðO$ð  ðO$ð ð	O$ð
 óO$ódó6óB)ðX!Øð!à5ó!óHðØ	ðà
ðð ðð 
ô	rG   