ó
    Ñ]j^F  ã                  óÖ  • S r SSKJr  SSKrSSKJrJr  SSKJrJ	r	J
r
JrJrJr  SSKrSSKJr  SSKrSSKrSSKJrJrJrJrJrJr  SSKrSSKJr  SS	KJr  SS
K J!r!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,  \(       a  SSK-J.r.J/r/J0r0J1r1J2r2J3r3  SSK4J5r5  S r6S r7SAS jr8S r9S r:SBS jr;SBS jr<SBS jr=SBS jr>SCS jr?\ SD     SES jj5       r@\SDSFS jj5       r@SGSFS jjr@ SG     SHS jjrAS rBSIS jrCSBS  jrDSBS! jrESJS" jrFSKS# jrGS$ rHS% rIS& rJ\SLS' j5       rK\    SMS( j5       rKSGSNS) jjrK\" S*5      rL\          SOS+ j5       rM\          SPS, j5       rM          SQS- jrMS. rN    SRS/ jrO\R                   SSSTS0 jj5       rQSUS1 jrR0 \R¦                  S2_\R¨                  S3_\Rª                  S4_\R¬                  S5_\R®                  S6_\R¦                  S2_\R°                  S2_\R²                  S7_\R´                  S7_\R¶                  S8_\R¸                  S8_\Rº                  S9_\R¼                  S9_\R¾                  S:_\RÀ                  S:_\RÂ                  S;_\RÄ                  S;_\R¨                  S3\RÆ                  S3\Rª                  S4\RÈ                  S4\RÊ                  S<\RÌ                  S<\RÎ                  S=\RÐ                  S=0EriSVS> jrjSWS? jrkS@ rlg)Xzh
Misc tools for implementing data structures

Note: pandas.core.common is *not* part of the public API.
é    )ÚannotationsN)ÚabcÚdefaultdict)ÚCallableÚ
CollectionÚ	GeneratorÚHashableÚIterableÚSequence)Úpartial)ÚTYPE_CHECKINGÚAnyÚConcatenateÚTypeVarÚcastÚoverload)Úlib)Ú'construct_1d_object_array_from_listlike)Úis_bool_dtypeÚ
is_integer)ÚABCExtensionArrayÚABCIndexÚABCMultiIndexÚABCNumpyExtensionArrayÚ	ABCSeries)Úiterable_not_string)Ú
Expression)ÚAnyArrayLikeÚ	ArrayLikeÚNpDtypeÚPÚRandomStateÚT)ÚIndexc              #  ót   #   • U  H,  n[        U5      (       a  [        U5       Sh  v•N   M(  Uv •  M.     g N7f)zÔ
Flatten an arbitrarily nested sequence.

Parameters
----------
line : sequence
    The non string sequence to flatten

Notes
-----
This doesn't consider strings sequences.

Returns
-------
flattened : generator
N)r   Úflatten)ÚlineÚelements     ÚO/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pandas/core/common.pyr&   r&   D   s2   é € ó" ˆÜ˜w×'Ñ'Ü˜wÓ'×'Ò'àŒMò	 á'ùs   ‚$8¦6§8c                ó�   • U S   R                   nU SS   H  n UR                   U:w  a  S n  U$ M     U$ ! [         a    S n   U$ f = f)Nr   é   )ÚnameÚ
ValueError)Úobjsr,   Úobjs      r)   Úconsensus_name_attrr0   \   si   € Ø�‰7�<‰<€DØ�A�B‹xˆð	Ø�x‰x˜4ÓØ�Øð €Kñ  ñ ð €Køô ó 	ØˆDÙØ€Kð	ús   ™4´AÁAc                ón  • [        U [        [        R                  [        [
        [        45      (       aª  [        U [        5      (       d•  U R                  [        R                  :X  aZ  [        R                  " U 5      n[        R                  " U5      (       d(  Sn[        R                  " USS9(       a  [        U5      egg[        U R                  5      (       a  g g[        U [        5      (       aB  [!        U 5      S:”  a3  [#        U 5      [        La  [        U 5      n [        R$                  " U 5      $ g)as  
Check whether `key` is a valid boolean indexer.

Parameters
----------
key : Any
    Only list-likes may be considered boolean indexers.
    All other types are not considered a boolean indexer.
    For array-like input, boolean ndarrays or ExtensionArrays
    with ``_is_boolean`` set are considered boolean indexers.

Returns
-------
bool
    Whether `key` is a valid boolean indexer.

Raises
------
ValueError
    When the array is an object-dtype ndarray or ExtensionArray
    and contains missing values.

See Also
--------
check_array_indexer : Check that `key` is a valid array to index,
    and convert to an ndarray.
z=Cannot mask with non-boolean array containing NA / NaN valuesT)ÚskipnaFr   )Ú
isinstancer   ÚnpÚndarrayr   r   r   r   ÚdtypeÚobject_Úasarrayr   Úis_bool_arrayr-   r   ÚlistÚlenÚtypeÚis_bool_list)ÚkeyÚ	key_arrayÚna_msgs      r)   Úis_bool_indexerrA   i   sì   € ô8 ØÜ	”B—J‘J¤Ô*;Ô=SÐT÷ñ ô ˜œm×,Ñ,Ø�9‰9œŸ
™
Ó"ÜŸ
š
 3›ˆIä×$Ò$ Y×/Ñ/ØX�Ü×$Ò$ Y°t×<ô % VÓ,Ð,ØØÜ˜3Ÿ9™9×%Ñ%Øð &ð ô 
�Cœ×	Ñ	äˆs‹8�a‹<Ü�C‹y¤Ò$ä˜3“i�Ü×#Ò# CÓ(Ð(àó    c                ó|   • [         R                  " U 5      (       a   U R                  5       (       a  [        S5      eU $ )zŽ
Disallow indexing with a float key, even if that key is a round number.

Parameters
----------
val : scalar

Returns
-------
outval : scalar
zYIndexing with a float is no longer supported. Manually convert to an integer key instead.)r   Úis_floatr   Ú
IndexError)Úvals    r)   Úcast_scalar_indexerrG   ¡   s8   € ô ‡|‚|�C×Ñ˜SŸ^™^×-Ñ-Üð)ó
ð 	
ð
 €JrB   c                 ó   • S U  5       $ )zD
Returns a generator consisting of the arguments that are not None.
c              3  ó.   #   • U  H  oc  M  Uv •  M     g 7f©N© ©Ú.0Úargs     r)   Ú	<genexpr>Únot_none.<locals>.<genexpr>»   s   é € Ð3š4�C�C‰Cš4ùs   ‚Œ	rK   ©Úargss    r)   Únot_nonerS   ·   s   € ñ 4™4Ó3Ð3rB   c                 ó&   • [        S U  5       5      $ )z7
Returns a boolean indicating if any argument is None.
c              3  ó(   #   • U  H  oS L v •  M
     g 7frJ   rK   rL   s     r)   rO   Úany_none.<locals>.<genexpr>Â   ó   é € Ð+¢d˜s�d�{¢dùó   ‚©ÚanyrQ   s    r)   Úany_noner[   ¾   ó   € ô Ñ+¡dÓ+Ó+Ð+rB   c                 ó&   • [        S U  5       5      $ )z9
Returns a boolean indicating if all arguments are None.
c              3  ó(   #   • U  H  oS L v •  M
     g 7frJ   rK   rL   s     r)   rO   Úall_none.<locals>.<genexpr>É   rW   rX   ©ÚallrQ   s    r)   Úall_nonerb   Å   r\   rB   c                 ó&   • [        S U  5       5      $ )z;
Returns a boolean indicating if any argument is not None.
c              3  ó(   #   • U  H  oS Lv •  M
     g 7frJ   rK   rL   s     r)   rO   Úany_not_none.<locals>.<genexpr>Ð   ó   é € Ð/ª$ 3˜$�ª$ùrX   rY   rQ   s    r)   Úany_not_nonerg   Ì   ó   € ô Ñ/©$Ó/Ó/Ð/rB   c                 ó&   • [        S U  5       5      $ )z=
Returns a boolean indicating if all arguments are not None.
c              3  ó(   #   • U  H  oS Lv •  M
     g 7frJ   rK   rL   s     r)   rO   Úall_not_none.<locals>.<genexpr>×   rf   rX   r`   rQ   s    r)   Úall_not_nonerl   Ó   rh   rB   c                 ó&   • [        S U  5       5      $ )z3
Returns the count of arguments that are not None.
c              3  ó(   #   • U  H  oS Lv •  M
     g 7frJ   rK   )rM   Úxs     r)   rO   Ú!count_not_none.<locals>.<genexpr>Þ   s   é € Ð+¢d ˜�}¢dùrX   )ÚsumrQ   s    r)   Úcount_not_nonerr   Ú   r\   rB   c                ó   • g rJ   rK   ©Úvaluesr6   s     r)   Úasarray_tuplesaferv   á   s   € ð rB   c                ó   • g rJ   rK   rt   s     r)   rv   rv   ë   s   € ØSVrB   c                óÈ  • [        U [        [        45      (       d  [        U S5      (       d  [        U 5      n OB[        U [        5      (       a  U R
                  $ [        U [        5      (       a  U R
                  $ [        U [        5      (       a%  U[        R                  [        4;   a  [        U 5      $  [        R                  " XS9n[        UR                  R                  [         5      (       a  [        R                  " U [        S9nUR"                  S:X  a&  U  Vs/ s H  n[        U5      PM     n n[        U 5      nU$ ! [         a    [        U 5      s $ f = fs  snf )NÚ	__array__©r6   é   )r3   r:   ÚtupleÚhasattrr   Ú_valuesr   r4   r7   Úobjectr   r8   r-   Ú
issubclassr6   r<   ÚstrÚndim)ru   r6   Úresultro   s       r)   rv   rv   ï   s  € Ü�v¤¤e˜}×-Ñ-´¸À×1MÑ1MÜ�f“‰Ü	�FœH×	%Ñ	%Ø�~‰~ÐÜ	�FœI×	&Ñ	&Ø�~‰~Ðä�&œ$×Ñ E¬b¯j©j¼&Ð-AÓ$AÜ6°vÓ>Ð>ð?Ü—’˜FÑ0ˆô �&—,‘,×#Ñ#¤S×)Ñ)Ü—’˜F¬&Ñ1ˆà‡{�{�aÓá$*Ó+¢F˜q”%˜–(¡FˆÐ+Ü8¸Ó@ˆà€Møô ó ?ô
 7°vÓ>Ò>ð?üò ,s   Â6E Ä EÅEÅEc                óÜ   • [        U [        [        45      (       a  U /n [        U [        [        R
                  45      (       d   [        U 5      n [        XS9nU$ ! [         a    U /n  Nf = f)zÇ
Transform label or iterable of labels to array, for use in Index.

Parameters
----------
dtype : dtype
    If specified, use as dtype of the resulting array, otherwise infer.

Returns
-------
array
rz   )r3   r�   r|   r:   r4   r5   Ú	TypeErrorrv   )Úlabelsr6   Úrlabelss      r)   Úindex_labels_to_arrayrˆ     si   € ô �&œ3¤˜,×'Ñ'Ø�ˆä�fœt¤R§Z¡ZÐ0×1Ñ1ð	Ü˜&“\ˆFô   Ñ4€Gà€Nøô ó 	Ø�XŠFð	ús   ÁA ÁA+Á*A+c                óH   • U b  [        U [        [        45      (       d  U /$ U $ rJ   )r3   r|   r:   ©r/   s    r)   Úmaybe_make_listr‹   +  s#   € Ø
�œz¨#´´t¨}×=Ñ=ØˆuˆØ€JrB   c                ó¸   • [        U [        R                  5      (       a*  [        U [        R                  5      (       d  [	        U 5      $ [        [        U 5      n U $ )z:
If obj is Iterable but not list-like, consume into list.
)r3   r   r
   ÚSizedr:   r   r   rŠ   s    r)   Úmaybe_iterable_to_listrŽ   1  s@   € ô �#”s—|‘|×$Ñ$¬Z¸¼S¿Y¹Y×-GÑ-GÜ�C‹yÐÜ
Œz˜3Ó
€CØ€JrB   c                ó    • [        U [        5      =(       a8    U R                  SL =(       a#    U R                  SL =(       a    U R                  SL $ )z
We have a null slice.
N©r3   ÚsliceÚstartÚstopÚsteprŠ   s    r)   Úis_null_slicer•   ;  sH   € ô
 	�3œÓ÷ 	Ø�I‰I˜Ð÷	à�H‰H˜Ð÷	ð �H‰H˜Ðð	rB   c                ó¶   • [        U [        5      =(       aC    U R                  SL=(       a.    U R                  SL=(       a    U R                  U R                  :H  $ )z6
We have an empty slice, e.g. no values are selected.
N)r3   r‘   r’   r“   rŠ   s    r)   Úis_empty_slicer—   G  sL   € ô
 	�3œÓ÷ 	"Ø�I‰I˜TÐ!÷	"à�H‰H˜DÐ ÷	"ð �I‰I˜Ÿ™Ñ!ð	rB   c              #  óp   #   • U  H,  n[        U[        5      =(       a    [        U5      (       + v •  M.     g7f)z3
Find non-trivial slices in "line": yields a bool.
N)r3   r‘   r•   )r'   Úks     r)   Úis_true_slicesrš   S  s+   é € ó ˆÜ˜œEÓ"×;¬=¸Ó+;Ô';Ô;ò ùs   ‚46c                ó¤   • [        U [        5      =(       a:    U R                  S:H  =(       a$    U R                  U:H  =(       a    U R                  SL $ )z
We have a full length slice.
r   Nr�   )r/   r'   s     r)   Úis_full_slicerœ   \  sG   € ô
 	�3œÓ÷ 	Ø�I‰I˜‰N÷	à�H‰H˜Ñ÷	ð �H‰H˜Ðð	rB   c                óÜ   • [        U S5      (       a  U R                  $ [        U [        5      (       a  [	        U R
                  5      $ [        U 5      (       a  [        U 5      R                  $ g )NÚ__name__)r}   rž   r3   r   Úget_callable_nameÚfuncÚcallabler<   rŠ   s    r)   rŸ   rŸ   h  sS   € äˆs�J×ÑØ�|‰|Ðä�#”w×ÑÜ  §¡Ó*Ð*ä�‡}�}Ü�C‹y×!Ñ!Ð!ð
 rB   c                óˆ   • [        U [        5      (       a  U R                  " U40 UD6$ [        U 5      (       a	  U " U40 UD6$ U $ )z¸
Evaluate possibly callable input using obj and kwargs if it is callable,
otherwise return as it is.

Parameters
----------
maybe_callable : possibly a callable
obj : NDFrame
**kwargs
)r3   r   Ú_eval_expressionr¡   )Úmaybe_callabler/   Úkwargss      r)   Úapply_if_callabler¦   y  sH   € ô �.¤*×-Ñ-Ø×.Ò.¨sÑ=°fÑ=Ð=Ü	�.×	!Ñ	!Ù˜cÑ, VÑ,Ð,àÐrB   c                ó4  • [         R                  " U 5      (       d:  [        U [        5      (       a  [	        [        U R
                  5      $ [        U 5      n [        U [        R                  5      (       d  [        SU  35      eU [        :X  a  [        S5      eU $ )aÕ  
Helper function to standardize a supplied mapping.

Parameters
----------
into : instance or subclass of collections.abc.Mapping
    Must be a class, an initialized collections.defaultdict,
    or an instance of a collections.abc.Mapping subclass.

Returns
-------
mapping : a collections.abc.Mapping subclass or other constructor
    a callable object that can accept an iterator to create
    the desired Mapping.

See Also
--------
DataFrame.to_dict
Series.to_dict
zunsupported type: z/to_dict() only accepts initialized defaultdicts)ÚinspectÚisclassr3   r   r   Údefault_factoryr<   r€   r   ÚMappingr…   )Úintos    r)   Ústandardize_mappingr­   Œ  sy   € ô* �?Š?˜4× Ñ Ü�dœK×(Ñ(Üœ;¨×(<Ñ(<Ó=Ð=Ü�D‹zˆÜ�dœCŸK™K×(Ñ(ÜÐ,¨T¨FÐ3Ó4Ð4ØŒ{ÓÜÐIÓJÐJØ€KrB   c                ó   • g rJ   rK   ©Ústates    r)   Úrandom_stater±   ¬  s   € ØEHrB   c                ó   • g rJ   rK   r¯   s    r)   r±   r±   °  s   € ð  rB   c                óº  • [        U 5      (       d9  [        U [        R                  [        R                  R
                  45      (       a  [        R                  R                  U 5      $ [        U [        R                  R                  5      (       a  U $ [        U [        R                  R                  5      (       a  U $ U c  [        R                  $ [        S5      e)a9  
Helper function for processing random_state arguments.

Parameters
----------
state : int, array-like, BitGenerator, Generator, np.random.RandomState, None.
    If receives an int, array-like, or BitGenerator, passes to
    np.random.RandomState() as seed.
    If receives an np.random RandomState or Generator, just returns that unchanged.
    If receives `None`, returns np.random.
    If receives anything else, raises an informative ValueError.

    Default None.

Returns
-------
np.random.RandomState or np.random.Generator. If state is None, returns np.random

zdrandom_state must be an integer, array-like, a BitGenerator, Generator, a numpy RandomState, or None)	r   r3   r4   r5   ÚrandomÚBitGeneratorr"   r   r-   r¯   s    r)   r±   r±   ¶  sœ   € ô( �%×ÑœJ u¬r¯z©z¼2¿9¹9×;QÑ;QÐ.R×SÑSÜ�y‰y×$Ñ$ UÓ+Ð+Ü	�Eœ2Ÿ9™9×0Ñ0×	1Ñ	1ØˆÜ	�Eœ2Ÿ9™9×.Ñ.×	/Ñ	/ØˆØ	‰Ü�y‰yÐäð+ó
ð 	
rB   Ú_Tc                ó   • g rJ   rK   ©r/   r    rR   r¥   s       r)   Úpiper¹   Ü  ó   € ð 	rB   c                ó   • g rJ   rK   r¸   s       r)   r¹   r¹   å  rº   rB   c                óŽ   • [        U[        5      (       a%  Uu  pEXS;   a  U S3n[        U5      eXU'   U" U0 UD6$ U" U /UQ70 UD6$ )a#  
Apply a function ``func`` to object ``obj`` either by passing obj as the
first argument to the function or, in the case that the func is a tuple,
interpret the first element of the tuple as a function and pass the obj to
that function as a keyword argument whose key is the value of the second
element of the tuple.

Parameters
----------
func : callable or tuple of (callable, str)
    Function to apply to this object or, alternatively, a
    ``(callable, data_keyword)`` tuple where ``data_keyword`` is a
    string indicating the keyword of ``callable`` that expects the
    object.
*args : iterable, optional
    Positional arguments passed into ``func``.
**kwargs : dict, optional
    A dictionary of keyword arguments passed into ``func``.

Returns
-------
object : the return type of ``func``.
z/ is both the pipe target and a keyword argument)r3   r|   r-   )r/   r    rR   r¥   Úfunc_ÚtargetÚmsgs          r)   r¹   r¹   î  sa   € ô: �$œ×Ñà‰ˆØÓØ�HÐKÐLˆCÜ˜S“/Ð!Øˆv‰Ù�dÐ%˜fÑ%Ð%á�CÐ)˜$Ò) &Ñ)Ð)rB   c                ób   ^ • U 4S jn[        T [        R                  [        45      (       a  U$ T $ )zj
Returns a function that will map names/labels, dependent if mapper
is a dict, Series or just a function.
c                ó   >• U T;   a  TU    $ U $ rJ   rK   )ro   Úmappers    €r)   ÚfÚget_rename_function.<locals>.f  s   ø€ Ø�‹;Ø˜!‘9ÐàˆHrB   )r3   r   r«   r   )rÂ   rÃ   s   ` r)   Úget_rename_functionrÅ     s*   ø€ õô ˜6¤C§K¡K´Ð#;×<Ñ<ˆ1ÐHÀ&ÐHrB   c                óò   • [        U [        [        R                  [        [
        [        45      (       a  U $ [        U [        R                  5      (       a   [        U [        5      (       d  [        U 5      $ U /$ )z˜
Convert list-like or scalar input to list-like. List, numpy and pandas array-like
inputs are returned unmodified whereas others are converted to list.
)
r3   r:   r4   r5   r   r   r   r   r
   r�   )ru   s    r)   Úconvert_to_list_likerÇ   &  sT   € ô �&œ4¤§¡¬X´yÔBSÐT×UÑUØˆÜ	�FœCŸL™L×	)Ñ	)´*¸VÄS×2IÑ2IÜ�F‹|Ðàˆ8€OrB   c              #  ó¬   #   • U(       a  [        X5      n[        XU5         U v •  U(       a  [        XW5        gg! U(       a  [        XW5        f f = f7f)a˜  
Temporarily set attribute on an object.

Parameters
----------
obj : object
    Object whose attribute will be modified.
attr : str
    Attribute to modify.
value : Any
    Value to temporarily set attribute to.
condition : bool, default True
    Whether to set the attribute. Provided in order to not have to
    conditionally use this context manager.

Yields
------
object : obj with modified attribute.
N)ÚgetattrÚsetattr)r/   ÚattrÚvalueÚ	conditionÚ	old_values        r)   Útemp_setattrrÏ   5  sL   é € ö* Ü˜CÓ&ˆ	Ü�˜5Ô!ð*ØŠ	æÜ�C˜yÕ)ð øŽ9Ü�C˜yÕ)ð üs   ‚A¢; ¦A»AÁAc                ó|   • [        U 5      [        U5      :w  a$  [        S[        U 5       S[        U5       S35      eg)z;
Check the length of data matches the length of the index.
zLength of values (z") does not match length of index (Ú)N)r;   r-   )ÚdataÚindexs     r)   Úrequire_length_matchrÔ   T  sI   € ô ˆ4ƒy”C˜“JÓÜðÜ�D“	ˆ{ð ä�E“
ˆ|˜1ðó
ð 	
ð rB   rq   ÚmaxÚminra   rZ   ÚmeanÚprodÚstdÚvarÚmedianÚcumprodÚcumsumc                ó,   • [         R                  U 5      $ )z@
if we define an internal function for this argument, return it
)Ú_cython_tableÚget)rN   s    r)   Úget_cython_funcrá   ~  s   € ô ×Ñ˜SÓ!Ð!rB   c                ó^   • [        U 5       VVs/ s H  u  pUc  SU 3OUPM     snn$ s  snnf )zç
If a name is missing then replace it by level_n, where n is the count

Parameters
----------
names : list-like
    list of column names or None values.

Returns
-------
list
    list of column names with the None values replaced.
Úlevel_)Ú	enumerate)ÚnamesÚir,   s      r)   Úfill_missing_namesrç   …  s6   € ô CLÈEÔBRÔSÒBR±w°q˜D™Lˆf�Q�C‰L¨dÒ2ÑBRÒSÐSùÓSs   �)c                ó~   • [         R                  " S5      nUR                  R                  5        H	  nX L d  M	    g   g)aQ  
Helper function used in detecting chained assignment.

If the pandas object (DataFrame/Series) is a local variable
in the caller's frame, it should not be a case of chained
assignment or method call.

For example:

def test():
    df = pd.DataFrame(...)
    df["a"] = 1  # not chained assignment

Inside ``df.__setitem__``, we call this function to check whether `df`
(`self`) is a local variable in `test` frame (the frame calling setitem). If
so, we know it is not a case of chained assignment (even when the refcount
of `df` is below the threshold due to optimization of local variables).
r{   TF)ÚsysÚ	_getframeÚf_localsru   )r/   ÚframeÚvs      r)   Úis_local_in_caller_framerî   –  s6   € ô& �MŠM˜!Ó€EØ�^‰^×"Ñ"Ö$ˆØŒ8Ùñ %ð rB   )r>   r   ÚreturnÚbool)rï   rð   )rï   Úint).)ru   zArrayLike | list | tuple | zipr6   úNpDtype | Nonerï   ú
np.ndarray)ru   r
   r6   rò   rï   r   rJ   )r†   znp.ndarray | Iterabler6   rò   rï   ró   )r/   zIterable[T] | Trï   zCollection[T] | T)r'   zabc.Iterablerï   zabc.Generator[bool, None, None])r'   rñ   rï   rð   )r°   únp.random.Generatorrï   rô   )r°   zHint | np.ndarray | np.random.BitGenerator | np.random.RandomState | Nonerï   znp.random.RandomState)r°   zRandomState | None)
r/   r¶   r    zCallable[Concatenate[_T, P], T]rR   zP.argsr¥   zP.kwargsrï   r#   )
r/   r   r    ztuple[Callable[..., T], str]rR   r   r¥   r   rï   r#   )
r/   r¶   r    z>Callable[Concatenate[_T, P], T] | tuple[Callable[..., T], str]rR   r   r¥   r   rï   r#   )ru   z"Hashable | Iterable | AnyArrayLikerï   zlist | AnyArrayLike)T)rË   r�   rÍ   rð   rï   zGenerator[None])rÓ   r$   rï   ÚNone)rN   r   rï   z
str | None)rå   zSequence[Hashable | None]rï   zlist[Hashable])mÚ__doc__Ú
__future__r   ÚbuiltinsÚcollectionsr   r   Úcollections.abcr   r   r   r	   r
   r   Ú
contextlibÚ	functoolsr   r¨   ré   Útypingr   r   r   r   r   r   Únumpyr4   Úpandas._libsr   Úpandas.core.dtypes.castr   Úpandas.core.dtypes.commonr   r   Úpandas.core.dtypes.genericr   r   r   r   r   Úpandas.core.dtypes.inferencer   Úpandas.core.colr   Úpandas._typingr   r   r    r!   r"   r#   Úpandasr$   r&   r0   rA   rG   rS   r[   rb   rg   rl   rr   rv   rˆ   r‹   rŽ   r•   r—   rš   rœ   rŸ   r¦   r­   r±   r¶   r¹   rÅ   rÇ   ÚcontextmanagerrÏ   rÔ   rq   rÕ   rÖ   ra   rZ   Únansumr×   ÚnanmeanrØ   ÚnanprodrÙ   ÚnanstdrÚ   ÚnanvarrÛ   Ú	nanmedianÚnanmaxÚnanminrÜ   Ú
nancumprodrÝ   Ú	nancumsumrß   rá   rç   rî   rK   rB   r)   Ú<module>r     sß  ðñõ #ã ÷÷÷ ó Ý Û Û 
÷÷ ó å å K÷÷õ õ =å &æ÷÷ õ òò0
ô5òpò,4ô,ô,ô0ô0ô,ð 
àDGðØ*ðØ3Aðàôó 
ðð 
Ý Vó 
Ø Vöð@ <@ðØ!ðØ*8ðàõò:ôô	ô	ô<ô	òò"ò&ð@ 
Û Hó 
Ø Hð 
ð ØSð àó ó 
ð ö
 
ñF ˆTƒ]€ð 
ðØ	ðà
)ðð ðð ð	ð
 óó 
ðð 
ðØ	ðà
&ðð ðð ð	ð
 óó 
ðð&*Ø	ð&*à
Hð&*ð ð&*ð ð	&*ð
 ô&*òRIðØ.ðàôð ×Ñõ*ó ð*ô<

ðØ‡L�L�%ðà‡L�L�%ðð ‡L�L�%ðð ‡F�FˆEð	ð
 ‡F�FˆEðð ‡F�FˆEðð ‡I�Iˆuðð ‡G�GˆVðð ‡J�J�ðð ‡G�GˆVðð ‡J�J�ðð ‡F�FˆEðð ‡I�Iˆuðð ‡F�FˆEðð ‡I�Iˆuðð  ‡I�Iˆxð!ð" ‡L�L�(ð#ð$ ‡F�FˆEØ‡I�IˆuØ‡F�FˆEØ‡I�IˆuØ‡J�J�	Ø‡M�M�9Ø‡I�IˆxØ‡L�L�(ñ3€ô:"ôTó"rB   