ó
    Ñ]j� ã                  ó¢  • % S SK Jr  S SKrS SKJr  S SKJr  S SKrS SKJr  S SK	r	S SK
JrJrJrJrJr  S SKrS SKJr  S SKJrJrJrJrJrJrJrJr  S S	KJr  S S
KJ r   S SK!J"r"J#r#  S SK$J%r%  S SK&J'r'J(r(J)r)J*r*J+r+  S SK,J-r-  S SK.J/r/J0r0J1r1  S SK2J3r3  S SK4J5s  J6r7  S SK8J9r9  S SK:J;r;J<r<  \(       a*  S SKJ=r=J>r>J?r?J@r@JArA  S SKBJCrCJDrDJErE  S SKFJGrG  S SKHJIrI  S SKJJKrK  \L\M\4   rNS\OS'   \#" S5       " S S\R                   5      5       rQ        S9                 S:S jjrR " S S \R¦                  S!9rT " S" S#\T5      rU " S$ S\U5      rV " S% S&\V5      rW " S' S(\V5      rX " S) S*\U5      rY " S+ S,\T5      rZ " S- S.\Z5      r[    S;S/ jr\S<S0 jr]    S=S1 jr^    S>S2 jr_          S?S3 jr`S@S4 jraSAS5 jrbSBS6 jrc    SCS7 jrdSDS8 jreg)Eé    )ÚannotationsN)Údefaultdict)ÚCallable)Úpartial)ÚTYPE_CHECKINGÚAnyÚLiteralÚ	TypeAliasÚcast)ÚBlockValuesRefs)ÚAggFuncTypeÚAggFuncTypeBaseÚAggFuncTypeDictÚ
AggObjTypeÚAxisÚAxisIntÚNDFrameTÚnpt)Úimport_optional_dependency)ÚSpecificationError)Úcache_readonlyÚ
set_module)Úis_nested_object)Úis_dict_likeÚis_extension_array_dtypeÚis_list_likeÚis_numeric_dtypeÚis_sequence)ÚExtensionDtype)ÚABCDataFrameÚ
ABCNDFrameÚ	ABCSeries)Úgenerate_apply_looper)Úensure_wrapped_if_datetimelike)Úget_jit_argumentsÚprepare_function_arguments)Ú	GeneratorÚHashableÚIterableÚMutableMappingÚSequence)Ú	DataFrameÚIndexÚSeries)ÚGroupBy)Ú	Resampler)Ú
BaseWindowr
   ÚResTypezpandas.api.executorsc                  ó¬   • \ rS rSrSr\\R                              SS j5       5       r\\R                              SS j5       5       r	Sr
g)	ÚBaseExecutionEngineéQ   a©  
Base class for execution engines for map and apply methods.

An execution engine receives all the parameters of a call to
``apply`` or ``map``, such as the data container, the function,
etc. and takes care of running the execution.

Supporting different engines allows functions to be JIT compiled,
run in parallel, and others. Besides the default executor which
simply runs the code with the Python interpreter and pandas.
c                ó   • g)a  
Executor method to run functions elementwise.

In general, pandas uses ``map`` for running functions elementwise,
but ``Series.apply`` with the default ``by_row='compat'`` will also
call this executor function.

Parameters
----------
data : Series, DataFrame or NumPy ndarray
    The object to use for the data. Some methods implement a ``raw``
    parameter which will convert the original pandas object to a
    NumPy array, which will then be passed here to the executor.
func : function or NumPy ufunc
    The function to execute.
args : tuple
    Positional arguments to be passed to ``func``.
kwargs : dict
    Keyword arguments to be passed to ``func``.
decorator : function, optional
    For JIT compilers and other engines that need to decorate the
    function ``func``, this is the decorator to use. While the
    executor may already know which is the decorator to use, this
    is useful as for a single executor the user can specify for
    example ``numba.jit`` or ``numba.njit(nogil=True)``, and this
    decorator parameter will contain the exact decorator from the
    executor the user wants to use.
skip_na : bool
    Whether the function should be called for missing values or not.
    This is specified by the pandas user as ``map(na_action=None)``
    or ``map(na_action='ignore')``.
N© )ÚdataÚfuncÚargsÚkwargsÚ	decoratorÚskip_nas         ÚN/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pandas/core/apply.pyÚmapÚBaseExecutionEngine.map_   ó   � ó    c                ó   • g)aW  
Executor method to run functions by an axis.

While we can see ``map`` as executing the function for each cell
in a ``DataFrame`` (or ``Series``), ``apply`` will execute the
function for each column (or row).

Parameters
----------
data : Series, DataFrame or NumPy ndarray
    The object to use for the data. Some methods implement a ``raw``
    parameter which will convert the original pandas object to a
    NumPy array, which will then be passed here to the executor.
func : function or NumPy ufunc
    The function to execute.
args : tuple
    Positional arguments to be passed to ``func``.
kwargs : dict
    Keyword arguments to be passed to ``func``.
decorator : function, optional
    For JIT compilers and other engines that need to decorate the
    function ``func``, this is the decorator to use. While the
    executor may already know which is the decorator to use, this
    is useful as for a single executor the user can specify for
    example ``numba.jit`` or ``numba.njit(nogil=True)``, and this
    decorator parameter will contain the exact decorator from the
    executor the user wants to use.
axis : {0 or 'index', 1 or 'columns'}
    0 or 'index' should execute the function passing each column as
    parameter. 1 or 'columns' should execute the function passing
    each row as parameter. The default executor engine passes rows
    as pandas ``Series``. Other executor engines should probably
    expect functions to be implemented this way for compatibility.
    But passing rows as other data structures is technically possible
    as far as the function ``func`` is implemented accordingly.
Nr7   )r8   r9   r:   r;   r<   Úaxiss         r>   ÚapplyÚBaseExecutionEngine.applyŠ   rA   rB   r7   N)r8   úSeries | DataFrame | np.ndarrayr9   r   r:   Útupler;   údict[str, Any]r<   zCallable | Noner=   Úbool)r8   rG   r9   r   r:   rH   r;   rI   r<   r   rD   r   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__ÚstaticmethodÚabcÚabstractmethodr?   rE   Ú__static_attributes__r7   rB   r>   r4   r4   Q   s¼   † ñ
ð Ø×Ñð'Ø-ð'àð'ð ð'ð ð	'ð
 #ð'ð ó'ó ó ð'ðR Ø×Ñð+Ø-ð+àð+ð ð+ð ð	+ð
 ð+ð ó+ó ó ó+rB   r4   Ú
FrameApplyc
                ó¾   • [        U40 U	D6u  p¡pºU R                  U5      nUS:X  a  [        nO#US:X  a  U(       a  [        SU< S35      e[        nW" U UUUUUUUU	S9	$ )z=construct and return a row or column based frame apply objectr   é   z-Named aggregation is not supported when axis=Ú.)ÚrawÚresult_typeÚby_rowÚengineÚengine_kwargsr:   r;   )Úreconstruct_funcÚ_get_axis_numberÚFrameRowApplyÚNotImplementedErrorÚFrameColumnApply)Úobjr9   rD   rX   rY   rZ   r[   r\   r:   r;   Ú_ÚcolumnsÚklasss                r>   Úframe_applyrf   º   s†   € ô +¨4Ñ:°6Ñ:Ñ€AˆWà×Ñ Ó%€DàˆqƒyÜ‰Ø	�‹ÞÜ%Ø@¸4¹'ÀÐCóð ô !ˆáØØØØØØØ#ØØñ
ð 
rB   c                  ó°  • \ rS rSr% S\S'   SSSS.               SS jjr\R                  SS	 j5       r\R                      SS
 j5       r	\R                      SS j5       r
SS jrSS jrSS jrSS jrSS jr        S S jr    S!S jrSS jr          S"S jr      S#S jrSS jrSS jr        S$S jrS%S jrSrg)&ÚApplyéá   r   rD   ÚcompatÚpythonN©rZ   r[   r\   c               óà   • Xl         X0l        USL d  US;   d   eXPl        U=(       d    SU l        U	=(       d    0 U l        X`l        Uc  0 OUU l        US;  a  [        S5      eX@l        X l	        g )NF)rj   Ú_compatr7   )NÚreduceÚ	broadcastÚexpandzUinvalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'})
rb   rX   rZ   r:   r;   r[   r\   Ú
ValueErrorrY   r9   )
Úselfrb   r9   rX   rY   rZ   r[   r\   r:   r;   s
             r>   Ú__init__ÚApply.__init__ä   sz   € ð ŒØŒà˜Š &Ð,AÓ"AÐAÐAØŒà—J˜BˆŒ	Ø—l ˆŒàŒØ#0Ñ#8™R¸mˆÔàÐEÓEÜð=óð ð
 'Ôà�	rB   c                ó   • g ©Nr7   ©rs   s    r>   rE   ÚApply.apply  ó   € àrB   c                ó   • g rw   r7   ©rs   Úop_names     r>   Úagg_or_apply_list_likeÚApply.agg_or_apply_list_like  ó   € ð 	rB   c                ó   • g rw   r7   r|   s     r>   Úagg_or_apply_dict_likeÚApply.agg_or_apply_dict_like  r€   rB   c                óæ   • U R                   n[        U[        5      (       a  U R                  5       $ [	        U5      (       a  U R                  5       $ [        U5      (       a  U R                  5       $ g)z‹
Provide an implementation for the aggregators.

Returns
-------
Result of aggregation, or None if agg cannot be performed by
this method.
N)r9   Ú
isinstanceÚstrÚ	apply_strr   Úagg_dict_liker   Úagg_list_like)rs   r9   s     r>   ÚaggÚ	Apply.agg  s`   € ð �y‰yˆä�dœC× Ñ Ø—>‘>Ó#Ð#ä˜×ÑØ×%Ñ%Ó'Ð'Ü˜$×Ñà×%Ñ%Ó'Ð'ð rB   c                óf  • U R                   nU R                  nU R                  nU R                  nU R                  nUR
                  S:H  nUR                  U5      S:X  a4  U(       a   eUR                  R                  " US/UQ70 UD6R                  $ [        U5      (       at  [        U5      (       dd  [        [        [           U5      nU(       a1  U Vs0 s H#  n[        R                  " U5      =(       d    UU_M%     nnO[         R#                  X5      n[        U5      (       a!  [        [$        U5      nU R'                  U5      $ [        [        U5      n U R)                  U5      n[1        U[2        [4        45      (       a-  UR6                  (       a  UR6                  (       d  [/        S5      e[1        U[2        [4        45      (       a*  UR8                  R;                  UR8                  5      (       d  [/        S5      eU$ s  snf ! [*         a    e [,         a  n	[/        S5      U	eSn	A	ff = f)zñ
Transform a DataFrame or Series.

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

Raises
------
ValueError
    If the transform function fails or does not transform.
rV   r   zTransform function failedNzFunction did not transform)rb   r9   rD   r:   r;   Úndimr^   ÚTÚ	transformr   r   r   Úlistr   ÚcomÚget_callable_nameÚdictÚfromkeysr   Útransform_dict_likeÚtransform_str_or_callableÚ	TypeErrorÚ	Exceptionrr   r…   r"   r    ÚemptyÚindexÚequals)
rs   rb   r9   rD   r:   r;   Ú	is_seriesÚvÚresultÚerrs
             r>   r�   ÚApply.transform.  sÑ  € ð �h‰hˆØ�y‰yˆØ�y‰yˆØ�y‰yˆØ—‘ˆà—H‘H ‘Mˆ	à×Ñ Ó%¨Ó*Þ Ð �=Ø—5‘5—?’? 4¨Ð<¨TÒ<°VÑ<×>Ñ>Ð>ä˜×Ñ¤l°4×&8Ñ&8Üœœ_Ñ-¨tÓ4ˆDæÙBFÓGÂ$¸Qœ×-Ò-¨aÓ0×5°A°qÒ8Á$�ÐG�ä—}‘} SÓ/�ä˜×ÑÜœ¨Ó.ˆDØ×+Ñ+¨DÓ1Ð1ô ”O TÓ*ˆð	CØ×3Ñ3°DÓ9ˆFô �v¤	¬<Ð8×9Ñ9Ø——Ø—I—IäÐ8Ó9Ð9Ü˜&¤9¬lÐ";×<Ñ<ÀFÇLÁL×DWÑDWØ�I‰I÷E
ñ E
ô Ð9Ó:Ð:àˆùò= Høô ó 	ØÜó 	CÜÐ8Ó9¸sÐBûð	Cús   Ã*HÅH ÈH0ÈH+È+H0c                ór  • SSK Jn  U R                  nU R                  nU R                  n[        U[        5      (       d   e[        U5      S:X  a  [        S5      eU R                  SX15      n0 nUR                  5        H.  u  pxUR                  USS9n	U	R                  " US/UQ70 UD6Xg'   M0     U" USS9$ )z3
Compute transform in the case of a dict-like func
r   ©Úconcatz$No transform functions were providedr�   rV   ©r�   ©rD   )Úpandas.core.reshape.concatr£   rb   r:   r;   r…   r!   Úlenrr   Únormalize_dictlike_argÚitemsÚ_gotitemr�   )
rs   r9   r£   rb   r:   r;   ÚresultsÚnameÚhowÚcolgs
             r>   r•   ÚApply.transform_dict_likem  s´   € õ 	6à�h‰hˆØ�y‰yˆØ—‘ˆô ˜#œz×*Ñ*Ð*Ð*äˆt‹9˜‹>ÜÐCÓDÐDà×*Ñ*¨;¸ÓBˆà68ˆØŸ™ž‰IˆDØ—<‘< ¨1�<Ð-ˆDØ ŸNšN¨3°ÐC°DÒC¸FÑCˆG‹Mñ &ñ �g AÑ&Ð&rB   c                ó  • U R                   nU R                  nU R                  n[        U[        5      (       a  U R
                  " X!/UQ70 UD6$  UR                  " U4SU0UD6$ ! [         a    U" U/UQ70 UD6s $ f = f)z<
Compute transform in the case of a string or callable func
r:   )rb   r:   r;   r…   r†   Ú
_apply_strrE   r˜   )rs   r9   rb   r:   r;   s        r>   r–   ÚApply.transform_str_or_callable…  s‡   € ð �h‰hˆØ�y‰yˆØ—‘ˆä�dœC× Ñ Ø—?’? 3Ð>¨tÒ>°vÑ>Ð>ð	.Ø—9’9˜TÑ7¨Ð7°Ñ7Ð7øÜó 	.Ù˜Ð-˜dÒ- fÑ-Ò-ð	.ús   ÁA& Á&A?Á>A?c                ó    • U R                  SS9$ )zb
Compute aggregation in the case of a list-like argument.

Returns
-------
Result of aggregation.
rŠ   ©r}   )r~   rx   s    r>   r‰   ÚApply.agg_list_like–  ó   € ð ×*Ñ*°5Ð*Ð9Ð9rB   c                ól  • [        [        [           U R                  5      nU R                  n/ n/ nUR
                  S:X  a²  U H©  nUR                  UR                  SUS9n	[        X5      (       a  U R                  /U R                  QOU R                  n
[        X‘5      " U/U
Q70 UD6nUR                  U5        [        R                  " U5      =(       d    UnUR                  U5        M«     Xv4$ / n[        U5       H“  u  pïUR                  USUR                   SS2U4   S9n	[        X5      (       a  U R                  /U R                  QOU R                  n
[        X‘5      " U/U
Q70 UD6nUR                  U5        UR                  U5        M•     UR"                  R%                  U5      nXv4$ )a¾  
Compute agg/apply results for like-like input.

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

Returns
-------
keys : list[Hashable] or Index
    Index labels for result.
results : list
    Data for result. When aggregating with a Series, this can contain any
    Python objects.
rV   ©r�   ÚsubsetN)r   r�   r   r9   rb   r�   rª   r¬   Úinclude_axisrD   r:   ÚgetattrÚappendr‘   r’   Ú	enumerateÚilocrd   Útake)rs   r}   Úselected_objr;   r9   rb   r«   ÚkeysÚar®   r:   Únew_resr¬   Úindicesrš   Úcols                   r>   Úcompute_list_likeÚApply.compute_list_like   sž  € ô4 ”DœÑ)¨4¯9©9Ó5ˆØ�h‰hˆàˆØˆð ×Ñ Ó!Û�Ø—|‘| L×$5Ñ$5¸AÀl�|ÐS�ô $ G×2Ñ2ð —Y‘YÐ+ §¡Ñ+àŸ™ð ô
 " $Ô0°ÐD°TÒD¸VÑD�Ø—‘˜wÔ'ô ×,Ò,¨QÓ/×4°1�Ø—‘˜DÖ!ñ ð< ˆ}Ðð ˆGÜ'¨Ö5‘
�Ø—|‘| C¨a¸×8IÑ8IÊ!ÈUÈ(Ñ8S�|ÐT�ô $ G×2Ñ2ð —Y‘YÐ+ §¡Ñ+àŸ™ð ô
 " $Ô0°ÐG¸ÒGÀÑG�Ø—‘˜wÔ'Ø—‘˜uÖ%ñ 6ð  ×'Ñ'×,Ñ,¨WÓ5ˆDàˆ}ÐrB   c                óÐ   • SSK Jn  U R                  n U" X!SSS9$ ! [         a?  nSSKJn  U" X!UR                  S9n[        U5      (       a  [        S5      UeUs S nA$ S nAff = f)	Nr   r¢   rV   F)rÁ   rD   Úsort©r.   ©rš   r¬   z3cannot combine transform and aggregation operations)	r¦   r£   rb   r—   Úpandasr.   r¬   r   rr   )rs   rÁ   r«   r£   rb   rŸ   r.   rž   s           r>   Úwrap_results_list_likeÚApply.wrap_results_list_likeâ  sn   € õ 	6à�h‰hˆð	Ù˜'°1¸5ÑAÐAøÜó 
	õ &á˜G°c·h±hÑ?ˆFÜ ×'Ñ'Ü ØIóàðð �Mûð
	ús   ” œ
A%¦4A ÁA%Á A%c                ó    • U R                  SS9$ )zb
Compute aggregation in the case of a dict-like argument.

Returns
-------
Result of aggregation.
rŠ   r´   )r‚   rx   s    r>   rˆ   ÚApply.agg_dict_like÷  r¶   rB   c                ó¼  • SSK JnJn  U R                  n[	        XuU45      n[        [        U R                  5      n	U R                  XU	5      n	UR                  S:H  =(       a0    UR                  R                  5       [        UR                  5      :  n
UR                  S:X  a`  UR                  USS9nU	R                  5        VVs/ s H  u  pÍ[        X±5      " U40 UD6PM     nnn[!        U	R#                  5       5      nXþ4$ U(       dþ  U
(       a÷  / n/ nU	R                  5        HÜ  u  nnUR                  R%                  U/5      nUR                  R'                  U5      n[)        [         5      n[+        UUSS9 H  u  nnUU   R-                  U5        M     UR                  5        VVVs/ s H1  u  nnU  H$  n[        UR/                  USS9U5      " U40 UD6PM&     M3     nnnnUU/[        U5      -  -  nUU-  nMÞ     Xþ4$ U(       aÛ  Un/ / pþU	R                  5        H¿  u  nnUU   nUR                  S:X  aF  UR                  USUS	9nUR-                  [        UU5      " U40 UD65        UR-                  U5        Ma  UR                  5        HJ  u  nnUR                  USUS	9nUR-                  [        UU5      " U40 UD65        UR-                  U5        ML     MÁ     Xþ4$ U	R                  5        VVs/ s H'  u  nn[        UR                  USS9U5      " U40 UD6PM)     nnn[!        U	R#                  5       5      nXþ4$ s  snnf s  snnnf s  snnf )
a3  
Compute agg/apply results for dict-like input.

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

Returns
-------
keys : list[hashable]
    Index labels for result.
results : list
    Data for result. When aggregating with a Series, this can contain any
    Python object.
r   ©ÚDataFrameGroupByÚSeriesGroupByé   rV   r¤   T©Ústrictr¥   r¸   )Úpandas.core.groupby.genericrÓ   rÔ   rb   r…   r   r   r9   r¨   r�   rd   Únuniquer§   rª   r©   r»   r�   rÁ   Úget_indexer_forr¿   r   Úzipr¼   Ú_ixs)rs   r}   rÀ   Ú	selectionr;   rÓ   rÔ   rb   Ú
is_groupbyr9   Úis_non_unique_colr®   rc   r­   r«   rÁ   ÚkeyrÄ   ÚlabelsÚlabel_to_indicesrš   ÚlabelÚindiceÚkey_dataÚdfÚcolsÚseriesrÅ   s                               r>   Úcompute_dict_likeÚApply.compute_dict_like  sG  € ÷:	
ð
 �h‰hˆÜ ¸Ð%FÓGˆ
Ü”O T§Y¡YÓ/ˆØ×*Ñ*¨7À$ÓGˆð ×Ñ Ñ"÷ KØ×$Ñ$×,Ñ,Ó.´°\×5IÑ5IÓ1JÑJð 	ð
 ×Ñ Ó!à—<‘< 	°�<Ð2ˆDØKOÏ:É:Ì<ÔXÊ<ÁÀ”w˜tÔ-¨cÑ<°VÔ<É<ˆGÑXÜ˜Ÿ	™	›Ó$ˆDðZ ˆ}ÐöY Ö 1ð ˆGØˆDØ ŸJ™JžL‘��SØ&×.Ñ.×>Ñ>À¸uÓE�Ø%×-Ñ-×2Ñ2°7Ó;�Ü#.¬tÓ#4Ð Ü$'¨°ÀÔ$E‘L�E˜5Ø$ UÑ+×2Ñ2°5Ö9ñ %Fð
 +;×*@Ñ*@Ô*Bõâ*B™˜˜wÜ")˜ô ˜L×-Ñ-¨f¸1Ð-Ð=¸wÔGÈÑVÈvÔVá")ñ WÙ*Bð ò ð ˜˜¤ H£Ñ-Ñ-�Ø˜8Ñ#’ñ )ðN ˆ}Ðö1 ð ˆBØ �TØ ŸJ™JžL‘��SØ˜#‘w�à—9‘9 “>Ø Ÿ\™\¨#°A¸d˜\ÐC�FØ—N‘N¤7¨6°7Ô#;¸CÑ#JÀ6Ñ#JÔKØ—K‘K Ö$à"&§*¡*¦,™˜˜3Ø!$§¡¨c¸À# Ð!F˜ØŸ™¤w¨v°wÔ'?ÀÑ'NÀvÑ'NÔOØŸ™ CÖ(ó #/ñ )ð& ˆ}Ðð	 !%§
¡
¤ôâ ,‘H�C˜ô ˜Ÿ™ S¨q˜Ð1°7Ô;¸CÑJÀ6ÔJÙ ,ð ñ ô ˜Ÿ	™	›Ó$ˆDàˆ}Ðùó] Yùôùó4s   ÃMÆ/8M
Ë>.Mc                óà  • SSK Jn  SSKJn  U R                  nU Vs/ s H  n[        U[        5      PM     nn[        U5      (       aÂ  U V	s/ s H  o™R                  (       a  M  U	PM     n
n	[        X#SS9 VVs/ s H  u  p¼UR                  (       a  M  UPM     nnnU/ :X  a  UnUn
UR                  S:X  a/  U" U5      nUR                  UR                  R                  5        Un[        U[        5      (       a  SOSnU" U
UUSS	9n	U	$ [        U5      (       a  [!        S
5      eSSK Jn  UR                  S:X  a  [%        SU5      nUR&                  nOS nU" X2US9n	U	$ s  snf s  sn	f s  snnf )Nr   ©r-   r¢   TrÖ   rÕ   rV   F)rD   rÁ   rÉ   zLcannot perform both aggregation and transformation operations simultaneouslyrÊ   r.   rË   )rÌ   r-   r¦   r£   rb   r…   r!   Úallr™   rÛ   r�   Ú
_set_namesrd   Únamesr"   Úanyrr   r.   r   r¬   )rs   rÀ   Úresult_indexÚresult_datar-   r£   rb   ÚrÚ
is_ndframerž   r«   Úkr�   Úkeys_to_useÚkturD   r.   r¬   s                     r>   Úwrap_results_dict_likeÚApply.wrap_results_dict_like`  sh  € õ 	!Ý5à�h‰hˆñ :EÓEº°A”j ¤JÖ/¹ˆ
ÐEäˆz�?‰?Ù,7ÓLªK &¿|½|—v©KˆGÐLô " ,ÀDÒIôÚI‘d�aÐQR×QXÕQX—ÑIð ñ ð ˜bÓ Ø*�Ø%�à× Ñ  AÓ%á˜KÓ(�Ø—‘˜|×3Ñ3×9Ñ9Ô:Ø!�ä!+¨C´×!;Ñ!;™AÀˆDÙØØØ Øñ	ˆFð4 ˆô) ��_‰_äð!óð õ &ð �x‰x˜1‹}Ü˜8 SÓ)�Ø—x‘x‘à�á˜KÀ$ÑGˆFàˆùò] Fùò Mùós   �E ÁE%Á%E%Á:E*ÂE*c                ó  • [        [        U R                  5      nU R                  nSSKJnJn  [        X!S5      n[        U5      (       a�  [        R                  " U5      n/ UR                  QUR                  Q7nU R                  S:w  a  SU;  d  US;   a  [        SU S35      eSU;   a+  [        X$U45      (       d  U R                  U R                   S'   U R"                  " X!/U R                  Q70 U R                   D6$ )zQ
Compute apply in case of a string.

Returns
-------
result: Series or DataFrame
r   rÒ   NrD   )ÚcorrwithÚskewz
Operation z does not support axis=1)r   r†   r9   rb   rØ   rÓ   rÔ   r»   ÚcallableÚinspectÚgetfullargspecr:   Ú
kwonlyargsrD   rr   r…   r;   r±   )rs   r9   rb   rÓ   rÔ   ÚmethodÚsigÚ	arg_namess           r>   r‡   ÚApply.apply_strœ  sä   € ô ”C˜Ÿ™Ó#ˆà�h‰hˆ÷	
ô ˜ DÓ)ˆÜ�F×ÑÜ×(Ò(¨Ó0ˆCØ4˜#Ÿ(™(Ð4 S§^¡^Ñ4ˆIØ�y‰y˜A‹~Ø˜iÓ'¨4Ð3GÓ+Gä  :¨d¨VÐ3KÐ!LÓMÐMØ˜Ó"¬:ØÐ%5Ð6÷,ñ ,ð '+§i¡i�—‘˜FÑ#Ø�Š˜sÐD¨4¯9©9ÒD¸¿¹ÑDÐDrB   c                óä  • U R                   S:X  a  [        S5      eU R                  S:X  aq  [        U R                  [
        5      (       aR  U R                  R                  R                  " U R                  S4SU R                  0U R                  D6R                  $ U R                  nU R                  n[        U5      (       a  U R                  SS9nOU R                  SS9n[        X140 UD6nU$ )z¯
Compute apply in case of a list-like or dict-like.

Returns
-------
result: Series, DataFrame, or None
    Result when self.func is a list-like or dict-like, None otherwise.
ÚnumbazIThe 'numba' engine doesn't support list-like/dict likes of callables yet.rV   r   r:   rE   r´   )r[   r`   rD   r…   rb   r    rŽ   rE   r9   r:   r;   r   r‚   r~   Úreconstruct_and_relabel_result)rs   r9   r;   rž   s       r>   Úapply_list_or_dict_likeÚApply.apply_list_or_dict_like¿  sÍ   € ð �;‰;˜'Ó!Ü%ð/óð ð
 �9‰9˜‹>œj¨¯©´<×@Ñ@Ø—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ˆàˆrB   c                óÄ  ^	• US;   d   eUS:X  a:  [        U[        5      (       a%  [        S UR                  5        5       5      (       d%  [        S UR                  5        5       5      (       a  [	        S5      eUR
                  S:w  ad  SSKJn  U" [        UR                  5       5      5      R                  UR                  S	S
9n[        U5      S:”  a  [        S[        U5       S35      e[        [        [        4m	[        U	4S jUR                  5        5       5      (       a9  0 nUR                  5        H!  u  px[        UT	5      (       d  U/Xg'   M  X†U'   M#     UnU$ )zÙ
Handler for dict-like argument.

Ensures that necessary columns exist if obj is a DataFrame, and
that a nested renamer is not passed. Also normalizes to all lists
when values consists of a mix of list and non-lists.
)rE   rŠ   r�   rŠ   c              3  ó<   #   • U  H  u  p[        U5      v •  M     g 7frw   )r   ©Ú.0rc   r�   s      r>   Ú	<genexpr>Ú/Apply.normalize_dictlike_arg.<locals>.<genexpr>î  s   é € Ð=²©¨”L —O�O²ùó   ‚c              3  ó<   #   • U  H  u  p[        U5      v •  M     g 7frw   )r   r  s      r>   r  r  ï  s   é € Ð;ªl¡d a”,˜q—/�/ªlùr  znested renamer is not supportedrV   r   rì   T)rÉ   z	Label(s) z do not existc              3  ó@   >#   • U  H  u  p[        UT5      v •  M     g 7frw   ©r…   )r  rc   ÚxÚaggregator_typess      €r>   r  r    s   øé € ÐHº<±4°1Œz˜!Ð-×.Ð.º<ùs   ƒ)r…   r"   rð   r©   r   r�   rÌ   r-   r�   rÁ   Ú
differencerd   r§   ÚKeyErrorrH   r“   )
rs   r­   rb   r9   r-   rç   Únew_funcrõ   r�   r  s
            @r>   r¨   Ú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‹}ä ¬4°«:¨,°mÐDÓEÐEä ¤%¬Ð.Ðô ÔH¸4¿:¹:¼<ÓH×HÑHØ(*ˆHØŸ
™
ž‘�Ü! !Ð%5×6Ñ6Ø#$ #�H“Kà"#˜Q“Kñ	 %ð
 ˆDØˆrB   c                óÀ  • [        U[        5      (       d   e[        X5      (       aO  [        X5      n[	        U5      (       a  U" U0 UD6$ [        U5      S:X  d   e[        S U 5       5      (       a   eU$ [        [        U5      (       a-  [        US5      (       a  [        [        U5      nU" U/UQ70 UD6$ SU S[        U5      R                   S3n[        U5      e)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              3  ó*   #   • U  H	  oS :H  v •  M     g7f)rD   Nr7   )r  Úkwargs     r>   r  Ú#Apply._apply_str.<locals>.<genexpr>  s   é € Ð?º¨u Fž?ºùs   ‚Ú	__array__Ú'z' is not a valid function for 'z' object)r…   r†   Úhasattrr»   rý   r§   rð   ÚnpÚtyperK   ÚAttributeError)rs   rb   r9   r:   r;   ÚfÚmsgs          r>   r±   ÚApply._apply_str  sØ   € ô ˜$¤×$Ñ$Ð$Ð$ä�3×ÑÜ˜Ó"ˆAÜ˜�{‰{Ù˜$Ð) &Ñ)Ð)ô �t“9 “>Ð!�>ÜÑ?¹Ó?×?Ñ?Ð?Ð?ØˆHÜ”R˜×Ñ¤7¨3°×#<Ñ#<äœ˜DÓ!ˆAÙ�SÐ*˜4Ò* 6Ñ*Ð*à�d�VÐ:¼4À»9×;MÑ;MÐ:NÈhÐWˆCÜ  Ó%Ð%rB   )	r:   rZ   r[   r\   r9   r;   rb   rX   rY   )rb   r   r9   r   rX   rJ   rY   ú
str | NonerZ   ú#Literal[False, 'compat', '_compat']r[   r†   r\   ú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;   rI   r*  z(tuple[list[Hashable] | Index, list[Any]])rÁ   úIterable[Hashable]r«   zlist[Series | DataFrame])
r}   r/  rÀ   r0  rÝ   zHashable | Sequence[Hashable]r;   rI   r*  z tuple[list[Hashable], list[Any]])rÀ   r0  rñ   zlist[Hashable]rò   r�   )r­   r†   rb   r-  r9   r   r*  r   )r9   r†   )rK   rL   rM   rN   Ú__annotations__rt   rQ   rR   rE   r~   r‚   rŠ   r�   r•   r–   r‰   rÆ   rÍ   rˆ   ré   rø   r‡   r  r¨   r±   rS   r7   rB   r>   rh   rh   á   sÎ  ‡ Ø
ƒMð 7?ØØ04ñ!àð!ð ð!ð ð	!ð
  ð!ð 4ð!ð ð!ð .ð!ð 
õ!ðF 	×Ñóó ðð 	×ÑðØ.ðà	óó ðð
 	×ÑðØ.ðà	óó ðô
ô.=ô~'ô0.ô":ð@à(ð@ð )ð@ð ð	@ð
 
2ô@ðDØ&ðØ1Iôô*:ð]à(ð]ð )ð]ð 1ð	]ð
 ð]ð 
*ô]ð~:à(ð:ð %ð:ð ô	:ôx!EôFð>,Øð,Ø/ð,Ø7Fð,à	ô,÷\&rB   rh   )Ú	metaclassc                  óp   • \ rS rSr% SrS\S'   \SS j5       r\SS j5       r    SS jr	    SS jr
S	rg
)ÚNDFrameApplyi(  z[
Methods shared by FrameApply and SeriesApply but
not GroupByApply or ResamplerWindowApply
r-  rb   c                ó.   • U R                   R                  $ rw   )rb   rš   rx   s    r>   rš   ÚNDFrameApply.index0  s   € à�x‰x�~‰~ÐrB   c                óL   • U R                   R                  U R                  5      $ rw   )rb   Ú_get_agg_axisrD   rx   s    r>   Úagg_axisÚNDFrameApply.agg_axis4  s   € à�x‰x×%Ñ% d§i¡iÓ0Ð0rB   c                ór  • U R                   nU R                  nUS:X  aW  [        U [        5      (       a  U R                  nO-[        U [
        5      (       a  U R                  (       a  SOSnOSn0 UESU0En[        USS5      S:X  a  [        S5      eU R                  XU5      u  pVU R                  XV5      nU$ )	NrE   rn   FrZ   rD   r   rV   ú"axis other than 0 is not supported)
rb   r;   r…   rT   rZ   ÚSeriesApplyr»   r`   rÆ   rÍ   )rs   r}   rb   r;   rZ   rÁ   r«   rž   s           r>   r~   Ú#NDFrameApply.agg_or_apply_list_like8  sª   € ð �h‰hˆØ—‘ˆà�gÓÜ˜$¤
×+Ñ+ØŸ™‘ä˜D¤+×.Ñ.Ø&*§k§k™°u‘à�Ø1˜Ð1 ¨&Ñ1ˆFä�3˜ Ó" aÓ'Ü%Ð&JÓKÐKà×.Ñ.¨w¸VÓD‰ˆØ×,Ñ,¨TÓ;ˆØˆrB   c                ó  • US;   d   eU R                   n0 nUS:X  a(  U R                  (       a  SOSnUR                  SU05        [        USS5      S:X  a  [	        S	5      eS nU R                  XXS5      u  pgU R                  X&U5      nU$ )
N©rŠ   rE   rE   rn   FrZ   rD   r   rV   r=  )rb   rZ   Úupdater»   r`   ré   rø   )	rs   r}   rb   r;   rZ   rÝ   rñ   rò   rž   s	            r>   r‚   Ú#NDFrameApply.agg_or_apply_dict_likeO  sš   € ð Ð*Ó*Ð*Ð*Ø�h‰hˆàˆØ�gÓØ"&§+§+‘Y°5ˆFØ�M‰M˜8 VÐ,Ô-ä�3˜ Ó" aÓ'Ü%Ð&JÓKÐKàˆ	Ø$(×$:Ñ$:Ø˜)ó%
Ñ!ˆð ×,Ñ,¨SÀÓLˆØˆrB   r7   N©r*  r-   r.  )rK   rL   rM   rN   rO   r2  Úpropertyrš   r:  r~   r‚   rS   r7   rB   r>   r5  r5  (  s_   ‡ ñð
 
Óàóó ðð ó1ó ð1ðØ.ðà	ôð.Ø.ðà	÷rB   r5  c                  óJ  ^ • \ rS rSr% S\S'   SSSS.               SU 4S jjjr\\R                  SS	 j5       5       r	\\R                  SS
 j5       5       r
\\R                  S S j5       5       r\\R                  \R                   S! S"S jj5       5       5       r\R                  S 5       rS#S jr\R                        S$S j5       r\SS j5       r\SS j5       r\S 5       rS%S jrU 4S jrS rS&S jrS'S jrS rS(S jrS rS$S jrS%U 4S jjr Sr!U =r"$ ))rT   ie  r,   rb   Frk   Nrl   c               ód   >• USLa  US:w  a  [        SU S35      e[        T
U ]	  UUUUUUUUU	S9	  g )NFrj   zby_row=z not allowed)rZ   r[   r\   r:   r;   )rr   Úsuperrt   )rs   rb   r9   rX   rY   rZ   r[   r\   r:   r;   Ú	__class__s             €r>   rt   ÚFrameApply.__init__h  sU   ø€ ð ˜Ò 6¨XÓ#5Ü˜w v h¨lÐ;Ó<Ð<Ü‰ÑØØØØØØØ'ØØð 	ò 
	
rB   c                ó   • g rw   r7   rx   s    r>   rñ   ÚFrameApply.result_index†  ó   € ð 	rB   c                ó   • g rw   r7   rx   s    r>   Úresult_columnsÚFrameApply.result_columns‹  rM  rB   c                ó   • g rw   r7   rx   s    r>   Úseries_generatorÚFrameApply.series_generator�  rM  rB   c                ó   • g rw   r7   )r9   ÚnogilÚnopythonÚparallels       r>   Úgenerate_numba_apply_funcÚ$FrameApply.generate_numba_apply_func•  s   € ð 	rB   c                ó   • g rw   r7   rx   s    r>   Úapply_with_numbaÚFrameApply.apply_with_numba�  rz   rB   c                óà   • U R                   R                  R                  5        HF  u  p[        U5      (       d  [	        SU SU S35      e[        U5      (       d  M9  [	        SU S35      e   g )NzColumn z# must have a numeric dtype. Found 'z	' insteadzM is backed by an extension array, which is not supported by the numba engine.)rb   Údtypesr©   r   rr   r   )rs   ÚcolnameÚdtypes      r>   Úvalidate_values_for_numbaÚ$FrameApply.validate_values_for_numba¡  s|   € à"Ÿh™hŸo™o×3Ñ3Ö5‰NˆGÜ# E×*Ñ*Ü Ø˜g˜Yð 'Ø#˜W Ið/óð ô (¨×.Ó.Ü Ø˜g˜Yð 'Bð Cóð ò 6rB   c                ó   • g rw   r7   ©rs   r«   Ú	res_indexs      r>   Úwrap_results_for_axisÚ FrameApply.wrap_results_for_axis¯  r€   rB   c                ó   • U R                   $ rw   )rO  rx   s    r>   Úres_columnsÚFrameApply.res_columns·  s   € à×"Ñ"Ð"rB   c                ó.   • U R                   R                  $ rw   )rb   rd   rx   s    r>   rd   ÚFrameApply.columns»  s   € à�x‰x×ÑÐrB   c                ó.   • U R                   R                  $ rw   )rb   Úvaluesrx   s    r>   rn  ÚFrameApply.values¿  s   € à�x‰x�‰ÐrB   c                óª  • [        U R                  5      (       a+  U R                  S:X  a  [        S5      eU R	                  5       $ [        U R                  5      S:X  a)  [        U R                  5      S:X  a  U R                  5       $ [        U R                  [        5      (       a+  U R                  S:X  a  [        S5      eU R                  5       $ [        U R                  [        R                  5      (       aŠ  U R                  S:X  a  [        S5      e[        R                  " SS9   U R                  R                   R#                  SU R                  S	9nS
S
S
5        U R                  R%                  WUR&                  S9$ U R(                  S:X  a6  U R                  S:X  a  [        S5      eU R+                  U R                  5      $ [-        U R                  R.                  5      (       d  U R                  5       $ U R0                  (       a$  U R3                  U R                  U R4                  S9$ U R7                  5       $ ! , (       d  f       Nñ= f)zcompute the resultsr  z9the 'numba' engine doesn't support lists of callables yetr   zJthe 'numba' engine doesn't support using a string as the callable functionzOthe 'numba' engine doesn't support using a numpy ufunc as the callable functionÚignore©rí   rE   )r9   N)Úaxesrp   z:the 'numba' engine doesn't support result_type='broadcast'©r[   r\   )r   r9   r[   r`   r  r§   rd   rš   Úapply_empty_resultr…   r†   r‡   r!  ÚufuncÚerrstaterb   Ú_mgrrE   Ú_constructor_from_mgrrs  rY   Úapply_broadcastrí   ÚshaperX   Ú	apply_rawr\   Úapply_standard©rs   r«   s     r>   rE   ÚFrameApply.applyÃ  sà  € ô ˜Ÿ	™	×"Ñ"Ø�{‰{˜gÓ%Ü)ØOóð ð ×/Ñ/Ó1Ð1ô ˆt�|‰|Ó Ó!¤c¨$¯*©*£o¸Ó&:Ø×*Ñ*Ó,Ð,ô �d—i‘i¤×%Ñ%Ø�{‰{˜gÓ%Ü)ð8óð ð —>‘>Ó#Ð#ô ˜Ÿ	™	¤2§8¡8×,Ñ,Ø�{‰{˜gÓ%Ü)ðCóð ô —’ Ó*ØŸ(™(Ÿ-™-×-Ñ-¨g¸D¿I¹IÐ-ÐF�÷ +ð —8‘8×1Ñ1°'ÀÇÁÐ1ÐMÐMð ×Ñ˜{Ó*Ø�{‰{˜gÓ%Ü)ØPóð ð ×'Ñ'¨¯©Ó1Ð1ô �T—X‘X—^‘^×$Ñ$Ø×*Ñ*Ó,Ð,ð �X�XØ—>‘>¨¯©ÀD×DVÑDV�>ÐWÐWà×"Ñ"Ó$Ð$÷+ +Õ*ús   Ä*/IÉ
Ic                óÀ  >• U R                   nU R                  nU R                  S:X  a  U R                   OU R                   R                  U l         SU l        S n [        TU ]  5       nXl         X l        US:X  a  Ub  UR                  OUnUc>  U R                   R
                  " U R                  U4SU R                  0U R                  D6nU$ ! Xl         X l        f = f)Nr   rV   r:   )	rb   rD   rŽ   rH  rŠ   rE   r9   r:   r;   )rs   rb   rD   rž   rI  s       €r>   rŠ   ÚFrameApply.aggù  sµ   ø€ Ø�h‰hˆØ�y‰yˆð  $Ÿy™y¨A›~�4—8’8°4·8±8·:±:ˆŒØˆŒ	àˆð	Ü‘W‘[“]ˆFàŒHØŒIà�1‹9Ø!'Ñ!3�V—X’X¸ˆFà‰>Ø—X‘X—^’^ D§I¡I¨tÑS¸$¿)¹)ÐSÀtÇ{Á{ÑSˆFàˆøð ŒHØ�Iús   ÁC ÃCc                óŠ  • [        U R                  5      (       d   eU R                  S;  a  U R                  R	                  5       $ U R                  S:H  nSSKJn  U(       d¦   U R                  S:X  a>  U R                  " U" / [        R                  S9/U R                  Q70 U R                  D6nOGU R                  " U" U R                  [        R                  S9/U R                  Q70 U R                  D6n[        X25      (       + nU(       a‹  [        U R                   5      (       a>  U R                  " U" / [        R                  S9/U R                  Q70 U R                  D6nO[        R"                  nU R                  R%                  X0R                   S9$ U R                  R	                  5       $ ! [         a     N¸f = f)z•
we have an empty result; at least 1 axis is 0

we will try to apply the function to an empty
series in order to see if this is a reduction function
)ro   Nro   r   rÊ   ©r`  )rš   r`  ©rš   )rý   r9   rY   rb   ÚcopyrÌ   r.   rD   r!  Úfloat64r:   r;   rd   r…   r˜   r§   r:  ÚnanÚ_constructor_sliced)rs   Úshould_reducer.   ró   s       r>   ru  ÚFrameApply.apply_empty_result  sg  € ô ˜Ÿ	™	×"Ñ"Ð"Ð"ð ×ÑÐ#3Ó3Ø—8‘8—=‘=“?Ð"ð ×(Ñ(¨HÑ4ˆå!æð:Ø—9‘9 “>ØŸ	š	Ù˜r¬¯©Ñ4ðØ7;·y±yòØDHÇKÁKñ‘Að Ÿ	š	Ù T§\¡\¼¿¹ÑDðàŸ™òð Ÿ+™+ñ�Aô %/¨qÓ$9Ô 9�æÜ�4—=‘=×!Ñ!Ø—I’I™f R¬r¯z©zÑ:ÐV¸T¿Y¹YÒVÈ$Ï+É+ÑV‘ä—F‘F�à—8‘8×/Ñ/°¿¹Ð/ÐGÐGà—8‘8—=‘=“?Ð"øô ó Ùðús   Á$BF5 Æ5
GÇGc                ó~  • S nUS:X  a€  [        U R                  U R                  U R                  SS9u  pE[	        U R                  40 [        U5      D6nU" U R                  U R                  /UQ76 n[        R                  " U5      nOT[        R                  " U" U R                  5      U R                  U R                  /U R                  Q70 U R                  D6nUR                  S:X  a.  U R                  R                  XpR                  U R                  S9$ U R                  R!                  XpR"                  S9$ )z$apply to the values as a numpy arrayc                ó   ^ • U 4S jnU$ )zi
Wrap user supplied function to work around numpy issue.

see https://github.com/numpy/numpy/issues/8352
c                 ót   >• T" U 0 UD6n[        U[        5      (       a  [        R                  " U[        S9nU$ )Nrƒ  )r…   r†   r!  ÚarrayÚobject)r:   r;   rž   r9   s      €r>   ÚwrapperÚ<FrameApply.apply_raw.<locals>.wrap_function.<locals>.wrapperH  s4   ø€ Ù˜tÐ. vÑ.�Ü˜f¤c×*Ñ*ÜŸXšX f´FÑ;�FØ�rB   r7   )r9   r�  s   ` r>   Úwrap_functionÚ+FrameApply.apply_raw.<locals>.wrap_functionA  s   ø€ õð ˆNrB   r  rV   ©Únum_required_argsrÕ   ©rš   rd   r„  )r&   r9   r:   r;   r#   r%   rn  rD   r!  ÚsqueezeÚapply_along_axisr�   rb   Ú_constructorrš   rd   rˆ  r:  )rs   r[   r\   r’  r:   r;   Ú	nb_looperrž   s           r>   r|  ÚFrameApply.apply_raw>  s  € ò	ð �WÓÜ5Ø—	‘	Ø—	‘	Ø—‘Ø"#ñ	‰LˆDô .Ø—	‘	ñä# MÓ2ñˆIñ ˜tŸ{™{¨D¯I©IÐ=¸Ò=ˆFä—Z’Z Ó'‰Fä×(Ò(Ù˜dŸi™iÓ(Ø—	‘	Ø—‘ðð —‘ò	ð
 —+‘+ñˆFð �;‰;˜!ÓØ—8‘8×(Ñ(¨·z±zÈ4Ï<É<Ð(ÐXÐXà—8‘8×/Ñ/°¿m¹mÐ/ÐLÐLrB   c                ó>  • [        U R                  5      (       d   e[        R                  " UR                  5      nUR
                  S   n[        UR                  5       HŠ  u  pEU R                  " X   /U R                  Q70 U R                  D6n[        R                  " U5      R                  nUS:”  a  [        S5      eUS:X  a  U[        U5      :w  a  [        S5      eXbS S 2U4'   MŒ     U R                  R                  X!R                   UR                  S9nU$ )Nr   rV   ztoo many dims to broadcastzcannot broadcast resultr–  )rý   r9   r!  Ú
empty_likern  r{  r½   rd   r:   r;   Úasarrayr�   rr   r§   rb   r™  rš   )	rs   ÚtargetÚresult_valuesÚresult_compareÚirÅ   ÚresÚaresrž   s	            r>   rz  ÚFrameApply.apply_broadcastq  sñ   € Ü˜Ÿ	™	×"Ñ"Ð"Ð"äŸš f§m¡mÓ4ˆð  Ÿ™ a™ˆä §¡Ö/‰FˆAØ—)’)˜F™KÐC¨$¯)©)ÒC°t·{±{ÑCˆCÜ—:’:˜c“?×'Ñ'ˆDð �a‹xÜ Ð!=Ó>Ð>Ø�q‹yà!¤S¨£XÓ-Ü$Ð%>Ó?Ð?à"%š!˜Q˜$Óñ 0ð —‘×&Ñ&Ø§¡°v·~±~ð 'ð 
ˆð ˆrB   c                óŽ   • U R                   S:X  a  U R                  5       u  pOU R                  5       u  pU R                  X5      $ )Nrk   )r[   Úapply_series_generatorÚapply_series_numbaÚwrap_resultsrd  s      r>   r}  ÚFrameApply.apply_standard�  sE   € Ø�;‰;˜(Ó"Ø!%×!<Ñ!<Ó!>ÑˆG�Yà!%×!8Ñ!8Ó!:ÑˆGð × Ñ  Ó4Ð4rB   c                óL  • [        U R                  5      (       d   eU R                  nU R                  n0 n[	        U5       H]  u  pEU R                  " U/U R
                  Q70 U R                  D6X4'   [        X4   [        5      (       d  MJ  X4   R                  SS9X4'   M_     X24$ )NF)Údeep)
rý   r9   rR  rñ   r½   r:   r;   r…   r"   r…  )rs   Ú
series_genre  r«   r¢  r�   s         r>   r§  Ú!FrameApply.apply_series_generator–  s•   € Ü˜Ÿ	™	×"Ñ"Ð"Ð"à×*Ñ*ˆ
Ø×%Ñ%ˆ	àˆä˜jÖ)‰DˆAØŸš 1Ð@ t§y¡yÒ@°D·K±KÑ@ˆG‰JÜ˜'™*¤i×0Ó0ð %™ZŸ_™_°%˜_Ð8�“
ñ *ð Ð!Ð!rB   c                óJ  • U R                   R                  SS5      (       a  [        S5      eU R                  R                  R
                  (       a  U R                  R
                  (       d  [        S5      eU R                  5         U R                  5       nXR                  4$ )NrW  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`   rb   rš   Ú	is_uniquerd   ra  r[  rñ   r~  s     r>   r¨  ÚFrameApply.apply_series_numba§  s…   € Ø×Ñ×!Ñ! *¨e×4Ñ4Ü%ØSóð ð �x‰x�~‰~×'×'¨t¯|©|×/E×/EÜ%ØTóð ð 	×&Ñ&Ô(Ø×'Ñ'Ó)ˆØ×)Ñ)Ð)Ð)rB   c                ó  • SSK Jn  [        U5      S:”  a*  SU;   a$  [        US   5      (       a  U R	                  X5      $ U R
                  R                  n[        U5      S:X  a  XCL a  U" U[        R                  S9nOU" U5      nX%l	        U$ )Nr   rÊ   rƒ  )
rÌ   r.   r§   r   rf  rb   rˆ  r!  r†  rš   )rs   r«   re  r.   Úconstructor_slicedrž   s         r>   r©  ÚFrameApply.wrap_results´  s€   € Ý!ô ˆw‹<˜!Ó  W£´¸WÀQ¹Z×1HÑ1HØ×-Ñ-¨gÓAÐAð "ŸX™X×9Ñ9ÐÜˆw‹<˜1ÓÐ!3Ò!=Ù'¨´r·z±zÑB‰Fá'¨Ó0ˆFØ ŒàˆrB   c                ó¼   >• U R                   S:X  a>  U R                  nUR                  U R                     nUR	                  X R
                  S9$ [        TU ]  5       $ )NÚsizer„  )r9   rb   r{  rD   rˆ  r:  rH  r‡   )rs   rb   ÚvaluerI  s      €r>   r‡   ÚFrameApply.apply_strÉ  sR   ø€ ð �9‰9˜Óà—(‘(ˆCØ—I‘I˜dŸi™iÑ(ˆEØ×*Ñ*¨5¿¹Ð*ÐFÐFÜ‰wÑ Ó"Ð"rB   )rD   rb   )rb   r   r9   r   rX   rJ   rY   r'  rZ   úLiteral[False, 'compat']r[   r†   r\   r)  r*  r+  rD  ©r*  zGenerator[Series]©TTF©r*  z5Callable[[npt.NDArray, Index, Index], dict[int, Any]])r*  r+  ©r«   r2   re  r-   r*  r-  r,  )rk   N©rŸ  r,   r*  r,   )r*  ztuple[ResType, Index])#rK   rL   rM   rN   r2  rt   rE  rQ   rR   rñ   rO  rR  rP   Ú	functoolsÚcacherX  r[  ra  rf  ri  rd   r   rn  rE   rŠ   ru  r|  rz  r}  r§  r¨  r©  r‡   rS   Ú__classcell__©rI  s   @r>   rT   rT   e  sÒ  ø‡ Ø	ƒNð ,1ØØ04ñ
àð
ð ð
ð ð	
ð
  ð
ð )ð
ð ð
ð .ð
ð 
÷
ð 
ð< Ø×Ñóó ó ðð Ø×Ñóó ó ðð Ø×Ñóó ó ðð Ø‡_�_Ø×Ñà27ðà	>ôó ó ó ðð
 	×Ññó ðôð 	×ÑðØðØ+0ðà	óó ðð ó#ó ð#ð ó ó ð ð ñó ðô4%õlò.,#ô\1Môfò85ô"ò"*ô÷*#õ #rB   c                  óº   • \ rS rSr% SrS\S'   \SS j5       r\\	R                   S SS jj5       5       rSS jr\SS j5       r\SS	 j5       r      SS
 jrSrg)r_   iÔ  r   r   rD   c                óT   ^ • U 4S j[        [        T R                  5      5       5       $ )Nc              3  óX   >#   • U  H  nTR                   R                  US S9v •  M!     g7f)rV   r¥   N)rb   rÜ   )r  r¢  rs   s     €r>   r  Ú1FrameRowApply.series_generator.<locals>.<genexpr>Ù  s$   øé € ÐKÒ2J¨Q�—‘—‘˜a a�Õ(Ò2Jùs   ƒ'*)Úranger§   rd   rx   s   `r>   rR  ÚFrameRowApply.series_generator×  s   ø€ äK´%¼¸D¿L¹LÓ8IÔ2JÓKÐKrB   c                ó¦   ^^^• [        S5      nSSKJm  SSKJm  UR
                  R                  U 5      mUR                  XUS9UUU4S j5       nU$ )Nr  r   rÊ   ©Úmaybe_cast_str©rU  rV  rW  c           	     óŽ   >• 0 n[        U R                  S   5       H%  nT" U S S 2U4   UT	" X   5      S9nT" U/UQ76 XE'   M'     U$ )NrV   rË   )rÈ  r{  )
rn  Ú	col_namesÚdf_indexr:   r«   ÚjÚserr.   Ú
jitted_udfrÌ  s
          €€€r>   Ú
numba_funcÚ;FrameRowApply.generate_numba_apply_func.<locals>.numba_funcë  sY   ø€ àˆGÜ˜6Ÿ<™<¨™?Ö+�áØš1˜a˜4‘L¨±~ÀiÁlÓ7Sñ�ñ (¨Ð3¨dÒ3�“
ñ ,ð ˆNrB   ©r   rÌ   r.   Úpandas.core._numba.extensionsrÌ  Ú	extendingÚregister_jitableÚjit©	r9   rU  rV  rW  r  rÔ  r.   rÓ  rÌ  s	         @@@r>   rX  Ú'FrameRowApply.generate_numba_apply_funcÛ  sV   ú€ ô
 +¨7Ó3ˆÝ!õ 	Aà—_‘_×5Ñ5°dÓ;ˆ
ð 
�‰˜¸HˆÐ	Eö	ó 
Fð	ð ÐrB   c           	     óî  • [        [        U R                  5      n[        XR                  U R
                  SS9u  p#U R                  " U40 [        U R                  5      D6nSSK	J
n  U R                  R                  nU R                  R                  nU" U5       oe" U5       n[        U" U R                  Xv/UQ76 5      nS S S 5        S S S 5        W$ ! , (       d  f       N= f! , (       d  f       W$ = f©NrV   r”  r   )Úset_numba_data©r   r   r9   r&   r:   r;   rX  r%   r\   r×  rß  rb   rš   rd   r“   rn  ©	rs   r9   r:   r;   Únb_funcrß  rš   rd   r£  s	            r>   r[  ÚFrameRowApply.apply_with_numbaø  sÊ   € Ü”H˜dŸi™iÓ(ˆÜ1Ø—)‘)˜TŸ[™[¸Añ
‰ˆð ×0Ò0Øñ
Ü% d×&8Ñ&8Ó9ñ
ˆõ 	Aà—‘—‘ˆØ—(‘(×"Ñ"ˆñ ˜EÔ" e¨^¸GÔ-DÈÜ‘w˜tŸ{™{¨GÐB¸TÒBÓCˆC÷ .E×"àˆ
÷ .EÕ-Dú×"Ô"àˆ
ús$   ÂC%Â$CÃC%Ã
C"	ÃC%Ã%
C4c                ó   • U R                   $ rw   ©rd   rx   s    r>   rñ   ÚFrameRowApply.result_index  ó   € à�|‰|ÐrB   c                ó   • U R                   $ rw   r„  rx   s    r>   rO  ÚFrameRowApply.result_columns  ó   € à�z‰zÐrB   c                óØ  • U R                   S:X  a#  U R                  R                  U5      nX#l        U$ U R                   cH  [	        S UR                  5        5       5      (       a#  U R                  R                  U5      nX#l        U$  U R                  R                  US9n[        US   [        5      (       d=  [        UR                  5      [        U R                  5      :X  a  U R                  Ul        [        UR                  5      [        U5      :X  a  X$l        U$ ! [         a=  nS[        U5      ;   a(  U R                  R                  U5      nX#l        Us SnA$ e SnAff = f)zreturn the results for the rowsro   Nc              3  óB   #   • U  H  n[        U[        5      v •  M     g 7frw   )r…   r“   )r  r  s     r>   r  Ú6FrameRowApply.wrap_results_for_axis.<locals>.<genexpr>  s   é € ð .
Ú)9 AŒJ�qœ$×ÐÒ)9ùs   ‚©r8   z%All arrays must be of the same lengthr   )rY   rb   rˆ  rš   rí   rn  r™  rr   r†   r…   r"   r§   ri  rd   )rs   r«   re  r£  rž   rŸ   s         r>   rf  Ú#FrameRowApply.wrap_results_for_axis  s4  € ð
 ×Ñ˜xÓ'à—(‘(×.Ñ.¨wÓ7ˆCØ!ŒIØˆJà×ÑÑ%¬#ñ .
Ø)0¯©Ô)9ó.
÷ +
ñ +
ð
 —(‘(×.Ñ.¨wÓ7ˆCØ!ŒIØˆJð
	Ø—X‘X×*Ñ*°Ð*Ð8ˆFô ˜' !™*¤i×0Ñ0Ü�6—<‘<Ó ¤C¨×(8Ñ(8Ó$9Ó9Ø#×/Ñ/�”äˆv�~‰~Ó¤# i£.Ó0Ø&ŒNàˆøô# ó 	Ø6¼#¸c»(ÓBð —h‘h×2Ñ2°7Ó;�Ø%”	Ø•
àûð	ús$   Â
D" Ä"
E)Ä,1E$ÅE)Å#E$Å$E)r7   Nr»  r¼  r½  ©r*  zdict[int, Any]rD  r¾  )rK   rL   rM   rN   rD   r2  rE  rR  rP   rÀ  rÁ  rX  r[  rñ   rO  rf  rS   r7   rB   r>   r_   r_   Ô  s•   ‡ Ø€Dˆ'ÓàóLó ðLð Ø‡_�_à27ðà	>ôó ó ðô6ð& óó ðð óó ðð'Øð'Ø+0ð'à	÷'rB   r_   c                  óÜ   ^ • \ rS rSr% SrS\S'   SU 4S jjr\SS j5       r\	\
R                   S SS jj5       5       rSS jr\SS	 j5       r\SS
 j5       r      SS jrSS jrSrU =r$ )ra   i=  rV   r   rD   c                óN   >• [         TU ]  UR                  5      nUR                  $ rw   )rH  rz  rŽ   )rs   rŸ  rž   rI  s      €r>   rz  Ú FrameColumnApply.apply_broadcast@  s   ø€ Ü‘Ñ(¨¯©Ó2ˆØ�x‰xˆrB   c              #  ó¨  #   • U R                   n[        U5      n[        U5      S:”  d   eU R                  R	                  SSS9nUR
                  nUR                  S   R                  R                  5       n[        UR                  [        5      (       a:  U R                  n[        [        U5      5       H  nUR	                  USS9v •  M     g [        XR                  SS9 Hh  u  pxX2l        UR                  U5        [         R#                  USU5        U(       d*  [%        UR                  S   5      UR                  S   l        Uv •  Mj     g 7f)Nr   r¥   TrÖ   Ú_name)rn  r$   r§   rb   rÜ   rx  ÚblocksÚrefsÚhas_referencer…   r`  r   rÈ  rÛ   rš   Ú
set_valuesr�  Ú__setattr__r   )	rs   rn  rÒ  ÚmgrÚis_viewrb   r¢  Úarrr¬   s	            r>   rR  Ú!FrameColumnApply.series_generatorD  s
  é € à—‘ˆÜ/°Ó7ˆÜ�6‹{˜Q‹Ðˆð �h‰h�m‰m˜A AˆmÐ&ˆØ�h‰hˆà—*‘*˜Q‘-×$Ñ$×2Ñ2Ó4ˆä�c—i‘i¤×0Ñ0ð —(‘(ˆCÜœ3˜s›8–_�Ø—h‘h˜q q�hÐ)Ô)ò %ô ! ¯©¸DÔA‘	�à”Ø—‘˜sÔ#Ü×"Ñ" 3¨°Ô6Þô *9¸¿¹ÀA¹Ó)G�C—J‘J˜q‘MÔ&Ø”	ò Bùs   ‚EEc                ó¦   ^^^• [        S5      nSSKJm  SSKJm  UR
                  R                  U 5      mUR                  XUS9UUU4S j5       nU$ )Nr  r   rÊ   rË  rÍ  c           	     ó    >• 0 n[        U R                  S   5       H.  nT" X   R                  5       UT	" X%   5      S9nT" U/UQ76 XE'   M0     U$ )Nr   rË   )rÈ  r{  r…  )
rn  Úcol_names_indexrš   r:   r«   r¢  rÒ  r.   rÓ  rÌ  s
          €€€r>   rÔ  Ú>FrameColumnApply.generate_numba_apply_func.<locals>.numba_funcs  s`   ø€ àˆGô ˜6Ÿ<™<¨™?Ö+�ñ Ø‘I—N‘NÓ$Ø)Ù'¨©Ó1ñ�ñ
 (¨Ð3¨dÒ3�“
ñ ,ð ˆNrB   rÖ  rÛ  s	         @@@r>   rX  Ú*FrameColumnApply.generate_numba_apply_funch  sQ   ú€ ô
 +¨7Ó3ˆÝ!Ý@à—_‘_×5Ñ5°dÓ;ˆ
à	�‰˜¸HˆÐ	Eö	ó 
Fð	ð  ÐrB   c           	     óÔ  • [        [        U R                  5      n[        XR                  U R
                  SS9u  p#U R                  " U40 [        U R                  5      D6nSSK	J
n  U" U R                  R                  5       nU" U R                  5       n[        U" U R                  Xv/UQ76 5      nS S S 5        S S S 5        W$ ! , (       d  f       N= f! , (       d  f       W$ = frÞ  rà  rá  s	            r>   r[  Ú!FrameColumnApply.apply_with_numba†  sÁ   € Ü”H˜dŸi™iÓ(ˆÜ1Ø—)‘)˜TŸ[™[¸Añ
‰ˆð ×0Ò0Øñ
Ü% d×&8Ñ&8Ó9ñ
ˆõ 	Añ
 ˜4Ÿ8™8Ÿ>™>Ô*¨eÙ˜4Ÿ<™<Ô(¨Gä‘w˜tŸ{™{¨GÐB¸TÒBÓCˆC÷ )÷ +ð
 ˆ
÷	 )Õ(ú÷ +Ô*ð
 ˆ
ús$   ÂCÂCÂ5CÃ
C	ÃCÃ
C'c                ó   • U R                   $ rw   r„  rx   s    r>   rñ   ÚFrameColumnApply.result_index›  rê  rB   c                ó   • U R                   $ rw   rå  rx   s    r>   rO  ÚFrameColumnApply.result_columnsŸ  rç  rB   c                óä   • U R                   S:X  a  U R                  X5      nU$ [        US   [        5      (       d#  U R                  R                  U5      nX#l        U$ U R                  X5      nU$ )z"return the results for the columnsrq   r   )rY   Úinfer_to_same_shaper…   r"   rb   rˆ  rš   ©rs   r«   re  rž   s       r>   rf  Ú&FrameColumnApply.wrap_results_for_axis£  ss   € ð ×Ñ˜xÓ'Ø×-Ñ-¨gÓAˆFð ˆô ˜G A™J¬	×2Ñ2Ø—X‘X×1Ñ1°'Ó:ˆFØ$ŒLð ˆð ×-Ñ-¨gÓAˆFàˆrB   c                ó|   • U R                   R                  US9nUR                  nX#l        UR	                  5       nU$ )z7infer the results to the same shape as the input objectrî  )rb   r™  rŽ   rš   Úinfer_objectsr  s       r>   r  Ú$FrameColumnApply.infer_to_same_shape¸  s>   € à—‘×&Ñ&¨GÐ&Ð4ˆØ—‘ˆð !Œð ×%Ñ%Ó'ˆàˆrB   r7   r¿  r»  r¼  r½  rð  rD  r¾  )r«   r2   re  r-   r*  r,   )rK   rL   rM   rN   rD   r2  rz  rE  rR  rP   rÀ  rÁ  rX  r[  rñ   rO  rf  r  rS   rÂ  rÃ  s   @r>   ra   ra   =  s¦   ø‡ Ø€Dˆ'Ó÷ð ó!ó ð!ðF Ø‡_�_à27ðà	>ôó ó ðô8ð* óó ðð óó ððØðØ+0ðà	ô÷*ò rB   ra   c                  ó–   ^ • \ rS rSr% S\S'   SrS\S'   S\S'   S	S
.       SU 4S jjjrSS jrU 4S jrSS jr	S r
SS jrSrU =r$ )r>  iÆ  r.   rb   r   r   rD   r(  rZ   rj   ©rZ   c          
     ó,   >• [         TU ]  UUSS UUUS9  g )NF)rX   rY   rZ   r:   r;   )rH  rt   )rs   rb   r9   rZ   r:   r;   rI  s         €r>   rt   ÚSeriesApply.__init__Ë  s,   ø€ ô 	‰ÑØØØØØØØð 	ò 	
rB   c                ój  • U R                   n[        U5      S:X  a  U R                  5       $ [        U R                  5      (       a  U R                  5       $ [        U R                  [        5      (       a  U R                  5       $ U R                  S:X  a  U R                  5       $ U R                  5       $ )Nr   rn   )rb   r§   ru  r   r9   r  r…   r†   r‡   rZ   Úapply_compatr}  ©rs   rb   s     r>   rE   ÚSeriesApply.applyÞ  s�   € Ø�h‰hˆäˆs‹8�q‹=Ø×*Ñ*Ó,Ð,ô ˜Ÿ	™	×"Ñ"Ø×/Ñ/Ó1Ð1ä�d—i‘i¤×%Ñ%à—>‘>Ó#Ð#à�;‰;˜)Ó#Ø×$Ñ$Ó&Ð&ð ×"Ñ"Ó$Ð$rB   c                ó¾   >• [         TU ]  5       nUcJ  U R                  nU R                  n[	        U5      (       d   eU" U/U R
                  Q70 U R                  D6nU$ rw   )rH  rŠ   rb   r9   rý   r:   r;   )rs   rž   rb   r9   rI  s       €r>   rŠ   ÚSeriesApply.aggò  sT   ø€ Ü‘‘“ˆØ‰>Ø—(‘(ˆCØ—9‘9ˆDä˜D—>‘>Ð!�>Ù˜#Ð9 §	¡	Ò9¨T¯[©[Ñ9ˆFØˆrB   c                ó~   • U R                   nUR                  UR                  UR                  S9R	                  USS9$ )N)r`  rš   rE   ©r  )rb   r™  r`  rš   Ú__finalize__r  s     r>   ru  ÚSeriesApply.apply_empty_resultü  sA   € Ø�h‰hˆØ×Ñ c§i¡i°s·y±yÐÐA×NÑNØ˜ð Oð 
ð 	
rB   c                ón  • U R                   nU R                  n[        U5      (       aO  [        R                  " U5      nU(       a2  U R
                  (       d!  U R                  (       d  UR                  USS9$  UR                  USS9nU$ ! [        [        [        4 a    UR                  USS9n U$ f = f)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
Fr  rj   )rb   r9   rý   r‘   Úget_cython_funcr:   r;   rE   rr   r#  r—   )rs   rb   r9   r$  rž   s        r>   r  Ú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   Á9B Â%B4Â3B4c                óê  ^ ^• [        [        T R                  5      mT R                  n[	        T[
        R                  5      (       a>  [
        R                  " SS9   T" U/T R                  Q70 T R                  D6sS S S 5        $ T R                  (       d   T" U/T R                  Q70 T R                  D6$ T R                  (       d  T R                  (       a  UU 4S jnOTnUR                  US9n[        U5      (       a;  [	        US   [        5      (       a#  UR                  [        U5      UR                   S9$ UR#                  X1R                   S9R%                  USS9$ ! , (       d  f       N»= f)	Nrq  rr  c                óD   >• T" U /TR                   Q70 TR                  D6$ rw   )r:   r;   )r  r9   rs   s    €€r>   ÚcurriedÚ+SeriesApply.apply_standard.<locals>.curried%  s    ø€ Ù˜AÐ9 §	¡	Ò9¨T¯[©[Ñ9Ð9rB   )Úmapperr   r„  rE   r  )r   r   r9   rb   r…   r!  rv  rw  r:   r;   rZ   Ú_map_valuesr§   r"   Ú_constructor_expanddimr�   rš   r™  r  )rs   rb   r$  Úmappedr9   s   `   @r>   r}  ÚSeriesApply.apply_standard  s  ù€ ä”H˜dŸi™iÓ(ˆØ�h‰hˆä�dœBŸH™H×%Ñ%Ü—’ Ó*Ù˜CÐ; $§)¡)Ò;¨t¯{©{Ñ;÷ +Ñ*à——Ù˜Ð7˜dŸi™iÒ7¨4¯;©;Ñ7Ð7à�9�9˜ŸŸ÷:ð ˆGØ—‘¨�Ð0ˆäˆv�;‰;œ: f¨Q¡i´×;Ñ;ð ×-Ñ-¬d°6«lÀ#Ç)Á)Ð-ÐLÐLà×#Ñ# F·)±)Ð#Ð<×IÑIØ˜Gð Jð ð ÷' +Õ*ús   Á E$Å$
E2r7   )rb   r.   r9   r   rZ   r(  r*  r+  r,  )r*  r.   )rK   rL   rM   rN   r2  rD   rt   rE   rŠ   ru  r  r}  rS   rÂ  rÃ  s   @r>   r>  r>  Æ  sk   ø‡ Ø	ƒKØ€Dˆ'ÓØ/Ó/ð 7?ñ
àð
ð ð
ð
 4ð
ð 
÷
ð 
ô&%õ(ô
ò÷,ò rB   r>  c                  ót   ^ • \ rS rSr% S\S'         S
U 4S jjrS rS r    SS jr    SS jr	S	r
U =r$ )ÚGroupByApplyi6  z GroupBy | Resampler | BaseWindowrb   c          	     óª   >• UR                  5       nUR                  R                  UR                  SS5      5      U l        [
        TU ]  UUSS UUS9  g )NrD   r   F©rX   rY   r:   r;   )r…  rb   r^   r°  rD   rH  rt   ©rs   rb   r9   r:   r;   rI  s        €r>   rt   ÚGroupByApply.__init__9  sU   ø€ ð —‘“ˆØ—G‘G×,Ñ,¨V¯Z©Z¸ÀÓ-BÓCˆŒ	Ü‰ÑØØØØØØð 	ò 	
rB   c                ó   • [         erw   ©r`   rx   s    r>   rE   ÚGroupByApply.applyL  ó   € Ü!Ð!rB   c                ó   • [         erw   r2  rx   s    r>   r�   ÚGroupByApply.transformO  r4  rB   c           	     ó²  • U R                   nU R                  nUS:X  a  0 UESS0En[        USS5      S:X  a  [        S5      eUR                  R
                  S:X  a  UR                  nOUR                  n[        R                  " USS	[        US5      S
9   U R                  XU5      u  pVS S S 5        U R                  WW5      nU$ ! , (       d  f       N"= f)NrE   rZ   FrD   r   rV   r=  Úas_indexT©Ú	condition)rb   r;   r»   r`   Ú_selected_objr�   Ú_obj_with_exclusionsr‘   Útemp_setattrr   rÆ   rÍ   )rs   r}   rb   r;   rÀ   rÁ   r«   rž   s           r>   r~   Ú#GroupByApply.agg_or_apply_list_likeR  sÕ   € ð �h‰hˆØ—‘ˆØ�gÓØ0˜Ð0 ¨%Ñ0ˆFä�3˜ Ó" aÓ'Ü%Ð&JÓKÐKà×Ñ×!Ñ! QÓ&à×,Ñ,‰Là×3Ñ3ˆLô ×ÒØ�˜T¬W°S¸*Ó-Eó
ð !×2Ñ2°7È&ÓQ‰MˆD÷
ð ×,Ñ,¨T°7Ó;ˆØˆ÷
õ 
ús   ÂCÃ
Cc           	     óˆ  • SSK JnJn  US;   d   eU R                  n0 nUS:X  a(  U R                  (       a  SOSnUR                  SU05        [        USS5      S	:X  a  [        S
5      eUR                  nUR                  n[        XBU45      n	U	(       aK  U R                  R                  SS 5      n
U R                  R                  SS 5      nUR                  X«S.5        [        R                  " USS[        US5      S9   U R!                  XX…5      u  pÍS S S 5        U R#                  UWW5      nU$ ! , (       d  f       N#= f)Nr   rÒ   rA  rE   rn   FrZ   rD   rV   r=  r[   r\   rt  r8  Tr9  )rØ   rÓ   rÔ   rb   rZ   rB  r»   r`   r;  Ú
_selectionr…   r;   r°  r‘   r=  r   ré   rø   )rs   r}   rÓ   rÔ   rb   r;   rZ   rÀ   rÝ   rÞ   r[   r\   rñ   rò   rž   s                  r>   r‚   Ú#GroupByApply.agg_or_apply_dict_likel  s+  € ÷	
ð
 Ð*Ó*Ð*Ð*à�h‰hˆØ!#ˆØ�gÓØ"&§+§+‘Y°5ˆFØ�M‰M˜8 VÐ,Ô-ä�3˜ Ó" aÓ'Ü%Ð&JÓKÐKà×(Ñ(ˆØ—N‘Nˆ	ä ¸Ð%FÓGˆ
ö Ø—[‘[—_‘_ X¨tÓ4ˆFØ ŸK™KŸO™O¨O¸TÓBˆMØ�M‰M VÑLÔMä×ÒØ�˜T¬W°S¸*Ó-Eó
ð )-×(>Ñ(>Ø yó)Ñ%ˆL÷
ð ×,Ñ,¨\¸<ÈÓUˆØˆ÷
õ 
ús   ÄD3Ä3
Er¥   )rb   zGroupBy[NDFrameT]r9   r   r*  r+  r.  )rK   rL   rM   rN   r2  rt   rE   r�   r~   r‚   rS   rÂ  rÃ  s   @r>   r,  r,  6  sc   ø‡ Ø	)Ó)ð
àð
ð ð
ð 
÷
ò&"ò"ðØ.ðà	ôð4%Ø.ð%à	÷%ò %rB   r,  c                  ó^   ^ • \ rS rSr% SrS\S'   S\S'         SU 4S jjrS rS	 rS
r	U =r
$ )ÚResamplerWindowApplyi”  r   r   rD   úResampler | BaseWindowrb   c          	     ó2   >• [         [        U ]  UUSS UUS9  g )NFr.  )rH  r,  rt   r/  s        €r>   rt   ÚResamplerWindowApply.__init__˜  s+   ø€ ô 	Œl˜DÑ*ØØØØØØð 	+ò 	
rB   c                ó   • [         erw   r2  rx   s    r>   rE   ÚResamplerWindowApply.apply©  r4  rB   c                ó   • [         erw   r2  rx   s    r>   r�   ÚResamplerWindowApply.transform¬  r4  rB   r7   )rb   rD  r9   r   r*  r+  )rK   rL   rM   rN   rD   r2  rt   rE   r�   rS   rÂ  rÃ  s   @r>   rC  rC  ”  sC   ø‡ Ø€Dˆ'ÓØ	Óð
à#ð
ð ð
ð 
÷
ò""÷"ð "rB   rC  c                ó–  ^	• SSK Jm	  U SL =(       a5    [        S0 UD6=(       d#    [        U	4S jUR	                  5        5       5      nSnSnU(       dO  [        U [        5      (       a,  [        U 5      [        [        U 5      5      :”  a  [        S5      eU c  [        S5      eU(       a™  0 nUR                  5        Hu  u  pg[        UT	5      (       a[  UR                  nUR                  (       d  UR                  (       a  X‡R                  UR                  4S jnUR                  U4XV'   Mq  XuU'   Mw     [!        U5      u  pnU c   eX X44$ )	aR  
This is the internal function to reconstruct func given if there is relabeling
or not and also normalize the keyword to get new order of columns.

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

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

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

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

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

>>> reconstruct_func("min")
(False, 'min', None, None)
r   )ÚNamedAggNc              3  ó<   >#   • U  H  n[        UT5      v •  M     g 7frw   r  )r  r�   rL  s     €r>   r  Ú#reconstruct_func.<locals>.<genexpr>Û  s   øé € Ð@²¨1Œz˜!˜X×&Ð&²ùs   ƒzFFunction names must be unique if there is no new column names assignedz4Must provide 'func' or tuples of '(column, aggfunc).c                ó   • U" U /UQ70 UD6$ rw   r7   )r  r9   rÂ   Úkws       r>   Ú<lambda>Ú"reconstruct_func.<locals>.<lambda>÷  s    € ÑQUØðRØòRØ!#òRrB   r7   )rØ   rL  Úis_multi_agg_with_relabelrð   rn  r…   r�   r§   Úsetr   r—   r©   Úaggfuncr:   r;   ÚcolumnÚnormalize_keyword_aggregation)
r9   r;   Ú
relabelingrd   ÚorderÚconverted_kwargsrà   ÚvalrU  rL  s
            @r>   r]   r]   °  s0  ø€ õN 5à˜�÷ Ü!Ñ+ FÑ+÷ 	AÜÔ@°·±´Ó@Ó@ð ð
 '+€GØ)-€EæÜ�dœD×!Ñ!¤c¨$£i´#´c¸$³i³.Ó&@ô %ØXóð ð ‰<äÐRÓSÐSæð ÐØŸ™ž‰HˆCÜ˜#˜x×(Ñ(ØŸ+™+�Ø—8—8˜sŸzŸzØ-4¿¹ÀSÇZÁZó �Gð *-¯©°WÐ(=Ð Ó%à(+ Ó%ñ 'ô  =Øó 
Ñˆ�uð ÑÐÐà˜WÐ+Ð+rB   c                 ól   • [        S U R                  5        5       5      =(       a    [        U 5      S:„  $ )a8  
Check whether kwargs passed to .agg look like multi-agg with relabeling.

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

Returns
-------
bool

Examples
--------
>>> is_multi_agg_with_relabel(a="max")
False
>>> is_multi_agg_with_relabel(a_max=("a", "max"), a_min=("a", "min"))
True
>>> is_multi_agg_with_relabel()
False
c              3  ól   #   • U  H*  n[        U[        5      =(       a    [        U5      S :H  v •  M,     g7f)rÕ   N)r…   rH   r§   )r  r�   s     r>   r  Ú,is_multi_agg_with_relabel.<locals>.<genexpr>  s'   é € ÐMº_¸Œz˜!œUÓ#×3¬¨A«°!©Ô3º_ùs   ‚24r   )rí   rn  r§   )r;   s    r>   rS  rS    s-   € ô* ÑM¸V¿]¹]¼_ÓMÓM÷ ÜˆF‹�a‰ðrB   c           
     ó(  • SSK Jn  [        [        5      n/ n[	        U R                  5       5      nU R                  5        HH  u  pVX%   R                  U5        UR                  U[        R                  " U5      =(       d    U45        MJ     [        U5      nUR                  5        VVVs/ s H0  u  pXU  H$  nU[        R                  " U5      =(       d    U4PM&     M2     n	nnn[        U	5      n
U" U
5      R                  U5      nX$U4$ s  snnnf )a  
Normalize user-provided "named aggregation" kwargs.
Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs
to the old Dict[str, List[scalar]]].

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

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

Examples
--------
>>> normalize_keyword_aggregation({"output": ("input", "sum")})
(defaultdict(<class 'list'>, {'input': ['sum']}), ('output',), array([0]))
r   rì   )Úpandas.core.indexes.baser-   r   r�   rH   rÁ   rn  r¼   r‘   r’   Ú_make_unique_kwarg_listr©   Úget_indexer)r;   r-   ÚaggspecrY  rd   rV  rU  Úuniquified_orderÚaggfuncsÚaggspec_orderÚuniquified_aggspecÚcol_idx_orders               r>   rW  rW  !  sû   € õ< /ô
 œ$Ó€GØ€EÜ�F—K‘K“MÓ"€Gà!Ÿ=™=ž?‰ˆØ‰×Ñ˜wÔ'Ø�‰�fœc×3Ò3°GÓ<×GÀÐHÖIñ +ô
 /¨uÓ5Ðð !(§¡¤õâ /ÑˆFÜˆGð 
”×&Ò& wÓ/×:°7Ó;áñ 	<Ù /ð ò ô
 1°Ó?Ðñ Ð,Ó-×9Ñ9Ð:JÓK€MØ˜]Ð*Ð*ùôs   Â,7Dc           
     óº   • [        U 5       VVs/ s H=  u  pU R                  U5      S:”  a!  US   US    SU SU R                  U5       34OUPM?     snn$ s  snnf )zû
Uniquify aggfunc name of the pairs in the order list

Examples:
--------
>>> kwarg_list = [("a", "<lambda>"), ("a", "<lambda>"), ("b", "<lambda>")]
>>> _make_unique_kwarg_list(kwarg_list)
[('a', '<lambda>_0'), ('a', '<lambda>_1'), ('b', '<lambda>')]
rV   r   rc   N)r½   Úcount)Úseqr¢  Úpairs      r>   ra  ra  ^  sl   € ô ! ”~ôâ%‰GˆAð :=¿¹À4»È1Ó9Lˆˆa‰�T˜!‘W�I˜Q˜s 2 A˜wŸ}™}¨TÓ2Ð3Ð4Ñ5ÐRVÒVÙ%òð ùó s   �AAc                óâ  • SSK Jn  [        [        X#SS9S S9 Vs/ s H  oUS   PM	     nn0 nSn[	        U [
        5      (       + =(       a    [        U R                  5      S:„  n	UR                  5        Hí  u  p«X
   R                  5       nU	(       aˆ  U Vs/ s H0  n[	        U[        5      (       d  [        R                  " U5      OUPM2     nnU" UR                  SS	9R                  U5      nUS
:g  nUR                  5       (       a  UR                   Xï      nUR"                  (       d  XhU[        U5      -    Ul        UR%                  U5      Xz'   U[        U5      -   nMï     U$ s  snf s  snf )aS  
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ì   TrÖ   c                ó   • U S   $ )NrV   r7   )Úts    r>   rQ  Ú relabel_result.<locals>.<lambda>–  s   € ÐSTÐUVÒSWrB   )rà   rV   F)r…  éÿÿÿÿ)r`  r-   ÚsortedrÛ   r…   r"   r§   rd   r©   Údropnar†   r‘   r’   rš   rb  rð   r¾   r™   Úreindex)rž   r9   rd   rY  r-   rl  Úreordered_indexesÚreordered_result_in_dictÚidxÚreorder_maskrÅ   ÚfunÚsr$  rh  Ú	valid_idxs                   r>   Úrelabel_resultr|  p  sZ  € õF /ô #¤3 w¸dÑ#CÉÒXóÚX�DˆQŒÑXð ð ð 8:ÐØ
€Cä! &¬)Ó4Ô4×P¼¸V¿^¹^Ó9LÈqÑ9P€LØ—J‘J–L‰ˆØ‰K×ÑÓ ˆö, áSVóÚSVÈa´
¸1¼c×0BÑ0B”×%Ò% aÔ(ÈÒIÑSVð ð ñ " !§'¡'°Ñ6×BÑBÀ3ÓGˆMØ%¨Ñ+ˆIØ�}‰}�‰Ø—F‘F˜=Ñ3Ñ4�ð �w�wØ'¨c´C¸³H©nÐ=ˆAŒGØ()¯	©	°'Ó(:Ð Ñ%Ø”C˜“H‰nŠñI !ðJ $Ð#ùòYùò>s   œE'Â7E,c                óv   • SSK Jn  [        U40 UD6u  pApVU(       a  Uc   eUc   e[        XXV5      nU" XuS9n U $ )Nr   )r,   r„  )rÌ   r,   r]   r|  )rž   r9   r;   r,   rX  rd   rY  Úresult_in_dicts           r>   r  r  Ä  sQ   € Ý ä'7¸Ñ'GÀÑ'GÑ$€J�gæð Ñ"Ð"Ð"ØÑ Ð Ð ä'¨°gÓEˆÙ˜>Ñ9ˆà€MrB   c                óÎ   • [        U 5      S::  a  U $ Sn/ nU  HI  n[        R                  " U5      S:X  a  [        U5      nSU S3Ul        US-  nUR                  U5        MK     U$ )a  
Possibly mangle a list of aggfuncs.

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

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

Notes
-----
If just one aggfunc is passed, the name will not be mangled.
rV   r   z<lambda>z<lambda_Ú>)r§   r‘   r’   r   rK   r¼   )re  r¢  Úmangled_aggfuncsrU  s       r>   Ú_managle_lambda_listr‚  ß  sv   € ô$ ˆ8ƒ}˜ÓàˆØ	€AØÐÛˆÜ× Ò  Ó)¨ZÓ7Ü˜gÓ&ˆGà!)¨!¨¨A˜ˆGÔØ�‰FˆAØ×Ñ Ö(ñ ð ÐrB   c                ó,  • [        U 5      nU(       d  [        U 5      (       d  U $ [        U 5      " 5       nU(       aM  U R                  5        H7  u  p4[        U5      (       a  [        U5      (       d  [	        U5      nOUnXRU'   M9     U$ [	        U 5      nU$ )a
  
Make new lambdas with unique names.

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

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

Examples
--------
>>> maybe_mangle_lambdas("sum")
'sum'
>>> maybe_mangle_lambdas([lambda: 1, lambda: 2])  # doctest: +SKIP
[<function __main__.<lambda_0>,
 <function pandas...._make_lambda.<locals>.f(*args, **kwargs)>]
)r   r   r"  r©   r‚  )Úagg_specÚis_dictÚmangled_aggspecrà   re  r�  s         r>   Úmaybe_mangle_lambdasr‡    sŠ   € ô2 ˜8Ó$€GÞ”| H×-Ñ-ØˆÜ˜8”nÓ&€OæØ%Ÿ^™^Ö-‰MˆCÜ˜H×%Ñ%¬l¸8×.DÑ.DÜ#7¸Ó#AÑ à#+Ð à#3˜CÓ ñ .ð Ðô /¨xÓ8ˆàÐrB   c                óB  • Sn[        U 5      n/ nU R                  5        Hf  n[        U[        5      (       d=  [	        U5      (       d-  [        UR                  [        U5      R                  5      5      eUR                  U5        Mh     U(       d  Sn[        U5      eX#4$ )aœ  
Validates types of user-provided "named aggregation" kwargs.
`TypeError` is raised if aggfunc is not `str` or callable.

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

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

Examples
--------
>>> validate_func_kwargs({"one": "min", "two": "max"})
(['one', 'two'], ['min', 'max'])
z-func is expected but received {} in **kwargs.z2Must provide 'func' or named aggregation **kwargs.)
r�   rn  r…   r†   rý   r—   Úformatr"  rK   r¼   )r;   Útuple_given_messagerd   r9   Úcol_funcÚno_arg_messages         r>   Ú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ˆÜ˜Ó'Ð'Øˆ=ÐrB   c                óh   • [        U[        5      =(       d    [        U[        5      =(       a    U S:H  $ )NrŠ   )r…   r    r"   )r}   r®   s     r>   rº   rº   Q  s*   € Ü�dœLÓ)÷ Ü�4œÓ#×8¨°5Ñ(8ðrB   )r   FNrj   rk   NNN)rb   r,   r9   r   rD   r   rX   rJ   rY   r'  rZ   rº  r[   r†   r\   r)  r*  rT   )r9   zAggFuncType | Noner*  zMtuple[bool, AggFuncType, tuple[str, ...] | None, npt.NDArray[np.intp] | None])r*  rJ   )r;   r“   r*  z]tuple[MutableMapping[Hashable, list[AggFuncTypeBase]], tuple[str, ...], npt.NDArray[np.intp]])rk  úSequence[tuple[Any, Any]]r*  r�  )
rž   r-  r9   zdict[str, list[Callable | str]]rd   r1  rY  zIterable[int]r*  zdict[Hashable, Series]r,  )re  úSequence[Any]r*  r�  )r„  r   r*  r   )r;   r“   r*  z0tuple[list[str], list[str | Callable[..., Any]]])r}   r/  r®   r0  r*  rJ   )fÚ
__future__r   rQ   Úcollectionsr   Úcollections.abcr   rÀ  r   rþ   Útypingr   r   r	   r
   r   Únumpyr!  Úpandas._libs.internalsr   Úpandas._typingr   r   r   r   r   r   r   r   Úpandas.compat._optionalr   Úpandas.errorsr   Úpandas.util._decoratorsr   r   Úpandas.core.dtypes.castr   Úpandas.core.dtypes.commonr   r   r   r   r   Úpandas.core.dtypes.dtypesr   Úpandas.core.dtypes.genericr    r!   r"   Úpandas.core._numba.executorr#   Úpandas.core.commonÚcoreÚcommonr‘   Úpandas.core.constructionr$   Úpandas.core.util.numba_r%   r&   r'   r(   r)   r*   r+   rÌ   r,   r-   r.   Úpandas.core.groupbyr/   Úpandas.core.resampler0   Úpandas.core.window.rollingr1   r“   Úintr2   r2  ÚABCr4   rf   ÚABCMetarh   r5  rT   r_   ra   r>  r,  rC  r]   rS  rW  ra  r|  r  r‚  r‡  r�  rº   r7   rB   r>   Ú<module>r«     sv  ðÞ "ã 
Ý #Ý $Û Ý Û ÷õ ó å 2÷	÷ 	ó 	õ ?Ý ,÷õ
 5÷õ õ 5÷ñ õ >ß  Ð  Ý C÷ö
 ÷õ ÷ñ õ
 ,Ý.Ý5à˜#˜s˜(‘^€ˆÓ #ñ Ð"Ó#ôe˜#Ÿ'™'ó eó $ðeðV ØØ"Ø'/ØØ,0Ø	Øð$Ø	ð$à
ð$ð ð$ð 
ð	$ð
 ð$ð %ð$ð ð$ð *ð$ð õ$ôND	&�c—k‘kò D	&ôN:�5ô :ôzl#�ô l#ô^f�Jô fôRF�zô FôRm�,ô mô`[�5ô [ô|"˜<ô "ð8T,Ø
ðT,àRôT,ônð4:+Øð:+ðô:+ðzØ	"ðàôð$Q$ØðQ$à
)ðQ$ð  ðQ$ð ð	Q$ð
 ôQ$ôhô6ôD)ðX!Øð!à5ô!õHrB   