o
    �¨ÊhRÙ  ã                   @  s>  d dl mZ d dlmZmZmZmZmZ d dlZd dl	Z
d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m!Z!m"Z" d dl#m$Z$ d d	l%m&Z& d d
l'm(Z( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z;m<Z<mZm=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ e�r	d dl[m\Z\m]Z] d dl^m_Z_ d dl`maZa d dlmbZbmcZc d dl`mdZd d dlemfZg G d d!„ d!eKeOƒZhd(d&d'„ZidS ))é    )Úannotations)ÚTYPE_CHECKINGÚAnyÚCallableÚLiteralÚoverloadN)ÚlibÚmissing)Úis_supported_dtype)Ú	ArrayLikeÚ	AstypeArgÚAxisIntÚDtypeObjÚFillnaOptionsÚInterpolateOptionsÚNpDtypeÚPositionalIndexerÚScalarÚScalarIndexerÚSelfÚSequenceIndexerÚShapeÚnpt)ÚIS64Úis_platform_windows©ÚAbstractMethodError)Údoc)Úvalidate_fillna_kwargs)ÚExtensionDtype)Úis_boolÚis_integer_dtypeÚis_list_likeÚ	is_scalarÚis_string_dtypeÚpandas_dtype)ÚBaseMaskedDtype)Úarray_equivalentÚis_valid_na_for_dtypeÚisnaÚnotna)Ú
algorithmsÚ	arrayliker	   ÚnanopsÚops)Úfactorize_arrayÚisinÚ	map_arrayÚmodeÚtake)Úmasked_accumulationsÚmasked_reductions)Úquantile_with_mask)ÚOpsMixin)Úto_numpy_dtype_inference)ÚExtensionArray)ÚarrayÚensure_wrapped_if_datetimelikeÚextract_array)Úcheck_array_indexer)Úinvalid_comparison)Ú
hash_array)ÚIteratorÚSequence)ÚSeries©ÚBooleanArray)ÚNumpySorterÚNumpyValueArrayLike©ÚFloatingArray)Úfunctionc                      sV  e Zd ZU dZded< ded< ded< eZeZe�d
dd„ƒZ		�d�ddd„Z
edddœ�ddd„ƒZeeejƒ�ddd„ƒƒZ�d�dd d!„Ze�dd#d$„ƒZe�dd(d)„ƒZe�dd+d)„ƒZ�dd.d)„Zddd/d0œ�dd7d8„Zeejƒ	/�d�dd9d:„ƒZedd;œ�dd>d?„ƒZd@dA„ Z�ddBdC„Z�d‡ fdDdE„Z�ddGdH„Z�ddJdK„Ze�ddLdM„ƒZe�ddNdO„ƒZ�ddPdQ„Z�d�ddUdV„Z�ddWdX„Z �ddYdZ„Z!e�dd[d\„ƒZ"�d�d d^d_„Z#�dd`da„Z$�ddbdc„Z%�dddde„Z&�ddfdg„Z'�d!dhdi„Z(dde)j*f�d"dmdn„Z+eej,ƒdodp„ ƒZ,e�d#�d$dsdt„ƒZ-e�d#�d%dvdt„ƒZ-e�d#�d&dydt„ƒZ-�d'�d&dzdt„Z-d{Z.	�d(�d)d~d„Z/d€ed�< �d*d…d†„Z0�d+d‡dˆ„Z1e�dd‰dŠ„ƒZ2�d,dŒd�„Z3dŽd�„ Z4e4Z5�d-d‘d’„Z6�d.d•d–„Z7�d!d—d˜„Z8ed™dš„ ƒZ9e�dd›dœ„ƒZ:e	R�d�d/dŸd „ƒZ;�d0d¥d¦„Z<dddRd§œ�d1d«d¬„Z=�d2d­d®„Z>�dd¯d°„Z?eej@ƒ	±�d3�d4d´dµ„ƒZ@�dd¶d·„ZAeejBƒ	¸	�d5�d6dÀdÁ„ƒZBeejCƒ	/�d'�d7dÄdÅ„ƒZCeejDƒ�d!dÆdÇ„ƒZD�d'�d8dÊdË„ZE�d'�d9dÌdÍ„ZFeejGƒ�ddÎdÏ„ƒZG�d:dÓdÔ„ZHd/ddÕœ�d;dÙdÚ„ZI�d<dÛdÜ„ZJdÝdÞ„ ZK�d<dßdà„ZLd/dRdRdáœ�d=dädå„ZMd/dRdRdáœ�d=dædç„ZNd/dRdèœ�d>dédê„ZOd/dRdëdìœ�d?dîdï„ZPd/dRdëdìœ�d?dðdñ„ZQd/dRdèœ�d>dòdó„ZRd/dRdèœ�d>dôdõ„ZS�d+död÷„ZTd/dRdèœ�d>dødù„ZUd/dRdèœ�d>dúdû„ZV�d@dþdÿ„ZWd/�d œ�dA�d�d„ZX�dB�d�d	„ZY‡  ZZS (C  ÚBaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   Ú_internal_fill_valueú
np.ndarrayÚ_dataúnpt.NDArray[np.bool_]Ú_maskÚvaluesÚmaskÚreturnr   c                 C  s   t  | ¡}||_||_|S ©N)rJ   Ú__new__rM   rO   )ÚclsrP   rQ   Úresult© rW   úK/var/www/html/env/lib/python3.10/site-packages/pandas/core/arrays/masked.pyÚ_simple_new|   s   
zBaseMaskedArray._simple_newFÚcopyÚboolÚNonec                 C  sX   t |tjƒr|jtjkstdƒ‚|j|jkrtdƒ‚|r$| ¡ }| ¡ }|| _	|| _
d S )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)Ú
isinstanceÚnpÚndarrayÚdtypeÚbool_Ú	TypeErrorÚshapeÚ
ValueErrorrZ   rM   rO   )ÚselfrP   rQ   rZ   rW   rW   rX   Ú__init__ƒ   s   ÿ
zBaseMaskedArray.__init__N©r`   rZ   c                C  s   | j |||d�\}}| ||ƒS )Nrg   )Ú_coerce_to_array)rU   Úscalarsr`   rZ   rP   rQ   rW   rW   rX   Ú_from_sequence–   s   
zBaseMaskedArray._from_sequencerc   r   r`   r   c                 C  s\   t j||jd�}| | j¡ t j|td�}| ||ƒ}t|| ƒr$||jkr,t	d|› d�ƒ‚|S )N©r`   z5Default 'empty' implementation is invalid for dtype='ú')
r^   ÚemptyÚtypeÚfillrK   Úonesr[   r]   r`   ÚNotImplementedError)rU   rc   r`   rP   rQ   rV   rW   rW   rX   Ú_empty›   s   

ÿzBaseMaskedArray._emptyÚboxedúCallable[[Any], str | None]c                 C  s   t S rS   )Ústr)re   rs   rW   rW   rX   Ú
_formatter¨   ó   zBaseMaskedArray._formatterr&   c                 C  ó   t | ƒ‚rS   r   ©re   rW   rW   rX   r`   ¬   ó   zBaseMaskedArray.dtypeÚitemr   r   c                 C  ó   d S rS   rW   ©re   r{   rW   rW   rX   Ú__getitem__°   rw   zBaseMaskedArray.__getitem__r   c                 C  r|   rS   rW   r}   rW   rW   rX   r~   ´   rw   r   ú
Self | Anyc                 C  sD   t | |ƒ}| j| }t|ƒr|r| jjS | j| S |  | j| |¡S rS   )r=   rO   r    r`   Úna_valuerM   rY   )re   r{   ÚnewmaskrW   rW   rX   r~   ¸   s   


T)ÚlimitÚ
limit_arearZ   Úmethodr   r‚   ú
int | Nonerƒ   ú#Literal['inside', 'outside'] | Nonec                C  sH  | j }| ¡ r˜tj|| jd�}| jj}|j}|r!| ¡ }| ¡ }n|d ur)| ¡ }||||d� |d urŒ| ¡ sŒ|j}| }	|	 	¡ }
t
|	ƒ|	d d d…  	¡  d }|dkrv|d |
…  |d |
… O  < ||d d …  ||d d … O  < n|dkrŒ||
d |…  ||
d |… O  < |r–|  |j|j¡S | S |r |  ¡ }|S | }|S )N©Úndim©r‚   rQ   éÿÿÿÿé   ÚinsideÚoutside)rO   Úanyr	   Úget_fill_funcrˆ   rM   ÚTrZ   ÚallÚargmaxÚlenrY   )re   r„   r‚   rƒ   rZ   rQ   ÚfuncÚnpvaluesÚnew_maskÚneg_maskÚfirstÚlastÚ
new_valuesrW   rW   rX   Ú_pad_or_backfillÄ   s:   
&$ÿz BaseMaskedArray._pad_or_backfillc           
      C  sÌ   t ||ƒ\}}| j}t ||t| ƒ¡}| ¡ rV|d urCtj|| jd�}| jj	}|j	}|r4| 
¡ }| 
¡ }||||d� |  |j	|j	¡S |rJ|  
¡ }	n| d d … }	||	|< |	S |r^|  
¡ }	|	S | d d … }	|	S )Nr‡   r‰   )r   rO   r	   Úcheck_value_sizer“   rŽ   r�   rˆ   rM   r�   rZ   rY   )
re   Úvaluer„   r‚   rZ   rQ   r”   r•   r–   rš   rW   rW   rX   Úfillnað   s.   
üÿzBaseMaskedArray.fillna©rZ   r   útuple[np.ndarray, np.ndarray]c                C  rx   rS   r   )rU   rP   r`   rZ   rW   rW   rX   rh     s   z BaseMaskedArray._coerce_to_arrayc                 C  s|   | j j}|dkrt |¡r|S n!|dkr!t |¡st |¡r |S nt |¡s/t |¡r1| ¡ r1|S tdt|ƒ› d| j › �ƒ‚)zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        ÚbÚfzInvalid value 'z' for dtype )r`   Úkindr   r    Ú
is_integerÚis_floatrb   ru   )re   r�   r£   rW   rW   rX   Ú_validate_setitem_value  s   
ÿÿz'BaseMaskedArray._validate_setitem_valuec                 C  sz   t | |ƒ}t|ƒr't|| jƒrd| j|< d S |  |¡}|| j|< d| j|< d S | j|| jd�\}}|| j|< || j|< d S )NTFrk   )r=   r#   r(   r`   rO   r¦   rM   rh   )re   Úkeyr�   rQ   rW   rW   rX   Ú__setitem__3  s   


ý


zBaseMaskedArray.__setitem__c                   sX   t |ƒr$|| jjur$| jjjdkr$t |¡r$tt 	| j¡| j
 @  ¡ ƒS ttƒ  |¡ƒS )Nr¢   )r)   r`   r€   rM   r£   r   r¥   r[   r^   ÚisnanrO   rŽ   ÚsuperÚ__contains__)re   r§   ©Ú	__class__rW   rX   r«   D  s   zBaseMaskedArray.__contains__r@   c                 c  s~   � | j dkr/| js| jD ]}|V  qd S | jj}t| j| jƒD ]\}}|r)|V  q|V  qd S tt| ƒƒD ]}| | V  q5d S )Nr‹   )	rˆ   Ú_hasnarM   r`   r€   ÚziprO   Úranger“   )re   Úvalr€   Úisna_ÚirW   rW   rX   Ú__iter__L  s   €

ÿüÿzBaseMaskedArray.__iter__Úintc                 C  s
   t | jƒS rS   )r“   rM   ry   rW   rW   rX   Ú__len__\  ó   
zBaseMaskedArray.__len__c                 C  ó   | j jS rS   )rM   rc   ry   rW   rW   rX   rc   _  rz   zBaseMaskedArray.shapec                 C  r¸   rS   )rM   rˆ   ry   rW   rW   rX   rˆ   c  rz   zBaseMaskedArray.ndimc                 C  s(   | j  ||¡}| j ||¡}|  ||¡S rS   )rM   ÚswapaxesrO   rY   )re   Úaxis1Úaxis2ÚdatarQ   rW   rW   rX   r¹   g  s   zBaseMaskedArray.swapaxesr   Úaxisr   c                 C  s0   t j| j||d�}t j| j||d�}|  ||¡S ©N©r½   )r^   ÚdeleterM   rO   rY   )re   Úlocr½   r¼   rQ   rW   rW   rX   rÀ   l  ó   zBaseMaskedArray.deletec                 O  s0   | j j|i |¤Ž}| jj|i |¤Ž}|  ||¡S rS   )rM   ÚreshaperO   rY   ©re   ÚargsÚkwargsr¼   rQ   rW   rW   rX   rÃ   q  rÂ   zBaseMaskedArray.reshapec                 O  s2   | j j|i |¤Ž}| jj|i |¤Ž}t| ƒ||ƒS rS   )rM   ÚravelrO   rn   rÄ   rW   rW   rX   rÇ   v  s   zBaseMaskedArray.ravelc                 C  s   |   | jj| jj¡S rS   )rY   rM   r�   rO   ry   rW   rW   rX   r�   |  s   zBaseMaskedArray.TÚdecimalsc                 O  sF   | j jdkr| S t ||¡ tj| jfd|i|¤Ž}|  || j 	¡ ¡S )aó  
        Round each value in the array a to the given number of decimals.

        Parameters
        ----------
        decimals : int, default 0
            Number of decimal places to round to. If decimals is negative,
            it specifies the number of positions to the left of the decimal point.
        *args, **kwargs
            Additional arguments and keywords have no effect but might be
            accepted for compatibility with NumPy.

        Returns
        -------
        NumericArray
            Rounded values of the NumericArray.

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r¡   rÈ   )
r`   r£   ÚnvÚvalidate_roundr^   ÚroundrM   Ú_maybe_mask_resultrO   rZ   )re   rÈ   rÅ   rÆ   rP   rW   rW   rX   rË   €  s
   zBaseMaskedArray.roundc                 C  s   |   | j | j ¡ ¡S rS   ©rY   rM   rO   rZ   ry   rW   rW   rX   Ú
__invert__£  ó   zBaseMaskedArray.__invert__c                 C  s   |   | j | j ¡ ¡S rS   rÍ   ry   rW   rW   rX   Ú__neg__¦  rÏ   zBaseMaskedArray.__neg__c                 C  s   |   ¡ S rS   rŸ   ry   rW   rW   rX   Ú__pos__©  s   zBaseMaskedArray.__pos__c                 C  s   |   t| jƒ| j ¡ ¡S rS   )rY   ÚabsrM   rO   rZ   ry   rW   rW   rX   Ú__abs__¬  s   zBaseMaskedArray.__abs__c                 C  s   t j| td�S )Nrk   )r^   ÚasarrayÚobjectry   rW   rW   rX   Ú_values_for_json±  s   z BaseMaskedArray._values_for_jsonúnpt.DTypeLike | Noner€   rÕ   c                 C  sî   | j }t| |||ƒ\}}|du rt}|rQ|tkr)t|ƒs)|tju r)td|› d�ƒ‚t ¡ � tj	dt
d� | j |¡}W d  ƒ n1 sEw   Y  ||| j< |S t ¡ � tj	dt
d� | jj||d�}W d  ƒ |S 1 spw   Y  |S )aF  
        Convert to a NumPy Array.

        By default converts to an object-dtype NumPy array. Specify the `dtype` and
        `na_value` keywords to customize the conversion.

        Parameters
        ----------
        dtype : dtype, default object
            The numpy dtype to convert to.
        copy : bool, default False
            Whether to ensure that the returned value is a not a view on
            the array. Note that ``copy=False`` does not *ensure* that
            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
            a copy is made, even if not strictly necessary. This is typically
            only possible when no missing values are present and `dtype`
            is the equivalent numpy dtype.
        na_value : scalar, optional
             Scalar missing value indicator to use in numpy array. Defaults
             to the native missing value indicator of this array (pd.NA).

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        An object-dtype is the default result

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a.to_numpy()
        array([True, False, <NA>], dtype=object)

        When no missing values are present, an equivalent dtype can be used.

        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
        array([ True, False])
        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
        array([1, 2])

        However, requesting such dtype will raise a ValueError if
        missing values are present and the default missing value :attr:`NA`
        is used.

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a
        <BooleanArray>
        [True, False, <NA>]
        Length: 3, dtype: boolean

        >>> a.to_numpy(dtype="bool")
        Traceback (most recent call last):
        ...
        ValueError: cannot convert to bool numpy array in presence of missing values

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.Úignore©ÚcategoryrŸ   )r®   r8   rÕ   r$   Ú
libmissingÚNArd   ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrM   ÚastyperO   )re   r`   rZ   r€   Úhasnar¼   rW   rW   rX   Úto_numpy´  s2   Bÿ

ÿ
þ

ý
þýzBaseMaskedArray.to_numpyc                 C  s>   | j dkrdd„ | D ƒS | jrd n| jj}| j|tjd� ¡ S )Nr‹   c                 S  s   g | ]}|  ¡ ‘qS rW   )Útolist©Ú.0ÚxrW   rW   rX   Ú
<listcomp>  s    z*BaseMaskedArray.tolist.<locals>.<listcomp>©r`   r€   )rˆ   r®   rM   r`   rã   rÛ   rÜ   rä   )re   r`   rW   rW   rX   rä     s   
zBaseMaskedArray.tolist.únpt.DTypeLikec                 C  r|   rS   rW   ©re   r`   rZ   rW   rW   rX   rá     rw   zBaseMaskedArray.astyper9   c                 C  r|   rS   rW   rë   rW   rW   rX   rá     rw   r   r   c                 C  r|   rS   rW   rë   rW   rW   rX   rá      rw   c                 C  s8  t |ƒ}|| jkr|r|  ¡ S | S t|tƒrRt ¡ � tjdtd� | j	j
|j|d�}W d   ƒ n1 s5w   Y  || j	u rB| jn| j ¡ }| ¡ }|||dd�S t|tƒrc| ¡ }|j| ||d�S |jdkrltj}n|jdkrwt d¡}ntj}|jd	v r†| jr†td
ƒ‚|jdkr’| jr’tdƒ‚| j|||d�}|S )NrØ   rÙ   rŸ   Frg   r¢   ÚMÚNaTÚiuzcannot convert NA to integerr¡   z cannot convert float NaN to bool)r`   r€   rZ   )r%   r`   rZ   r]   r&   rÝ   rÞ   rß   rà   rM   rá   Únumpy_dtyperO   Úconstruct_array_typer   rj   r£   r^   ÚnanÚ
datetime64r   Ú
no_defaultr®   rd   rã   )re   r`   rZ   r¼   rQ   rU   Úeaclsr€   rW   rW   rX   rá   $  s6   


ý


iè  úNpDtype | Noneúbool | Nonec                 C  s   | j |d�S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rk   )rã   rë   rW   rW   rX   Ú	__array__T  s   zBaseMaskedArray.__array__ztuple[type, ...]Ú_HANDLED_TYPESÚufuncúnp.ufuncru   c           	        sb  |  dd¡}|| D ]}t|| jtf ƒst  S q
tj| ||g|¢R i |¤Ž}|tur.|S d|v r@tj| ||g|¢R i |¤ŽS |dkrXtj| ||g|¢R i |¤Ž}|turX|S t	j
t| ƒtd�‰ g }|D ]}t|tƒrxˆ |jO ‰ | |j¡ qe| |¡ qed‡ fdd„‰t||ƒ|i |¤Ž}|jd	krŸt‡fd
d„|D ƒƒS |dkr­| j ¡ r«| jS |S ˆ|ƒS )NÚoutrW   Úreducerk   rç   rL   c                   s”   ddl m}m}m} | jjdkrˆ  ¡ }|| |ƒS | jjdv r(ˆ  ¡ }|| |ƒS | jjdkrCˆ  ¡ }| jtjkr>|  	tj
¡} || |ƒS tj| ˆ < | S )Nr   )rD   rH   ÚIntegerArrayr¡   rî   r¢   )Úpandas.core.arraysrD   rH   rý   r`   r£   rZ   r^   Úfloat16rá   Úfloat32rñ   )rç   rD   rH   rý   Úm©rQ   rW   rX   Úreconstruct†  s   



z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructr‹   c                 3  s   � | ]}ˆ |ƒV  qd S rS   rW   rå   )r  rW   rX   Ú	<genexpr>£  s   € z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)rç   rL   )Úgetr]   rø   rJ   ÚNotImplementedr,   Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr^   Úzerosr“   r[   rO   ÚappendrM   ÚgetattrÚnoutÚtuplerŽ   Ú	_na_value)	re   rù   r„   ÚinputsrÆ   rû   rç   rV   Úinputs2rW   )rQ   r  rX   Ú__array_ufunc___  s`   ÿÿÿÿÿÿÿÿÿÿ



zBaseMaskedArray.__array_ufunc__c                 C  s   ddl }|j| j| j|d�S )z6
        Convert myself into a pyarrow Array.
        r   N)rQ   rn   )Úpyarrowr:   rM   rO   )re   rn   ÚparW   rW   rX   Ú__arrow_array__¬  s   zBaseMaskedArray.__arrow_array__c                 C  ó
   | j  ¡ S rS   )rO   rŽ   ry   rW   rW   rX   r®   ´  s   
zBaseMaskedArray._hasnaúnpt.NDArray[np.bool_] | Nonec                 C  s^   |d u r(| j  ¡ }|tju r|dB }|S t|ƒr&t|ƒt|ƒkr&|t|ƒB }|S | j |B }|S )NT)rO   rZ   rÛ   rÜ   r"   r“   r)   )re   rQ   ÚotherrW   rW   rX   Ú_propagate_mask½  s   

ú
ýzBaseMaskedArray._propagate_maskc           	      C  sz  |j }d }t|dƒs t|ƒr t|ƒt| ƒkr t|ƒ}t|dd�}t|tƒr-|j|j	}}nt|ƒrDt|t
ƒs;t |¡}|jdkrDtdƒ‚t |t| ƒf¡}t |¡}t|ƒ}|dv rdt|tjƒrdt|ƒ}|  ||¡}|tju r§t | j¡}| jjdkr–|dv r‡td	|› d
�ƒ‚|dv rŽd}nd}| |¡}n9d|v r¦| jjdkr¦| tj¡}n(| jjdv r³|dv r³|}tjdd�� || j|ƒ}W d   ƒ n1 sÊw   Y  |dk�rt | jdk| j	 @ d|¡}|d urót |dk| @ d|¡}nD|tju�rt |dkd|¡}n4|dk�r7|d u�rt |dk| @ d|¡}n|tju�r)t |dkd|¡}t | jdk| j	 @ d|¡}|  ||¡S )Nr`   T)Úextract_numpyr‹   ú(can only perform ops with 1-d structures>   ÚpowÚrpowr¡   >   r  r  ÚtruedivÚfloordivÚrtruedivÚ	rfloordivz
operator 'z!' not implemented for bool dtypes>   ÚmodÚrmodÚint8r[   r  r¢   rî   )r  r"  rØ   )r‘   r  Fr   r  ) Ú__name__Úhasattrr"   r“   Úpd_arrayr<   r]   rJ   rM   rO   r9   r^   rÔ   rˆ   rq   r.   Úmaybe_prepare_scalar_for_opÚget_array_opr;   ra   r[   r  rÛ   rÜ   Ú	ones_liker`   r£   rá   Úfloat64ÚerrstateÚwhererÌ   )	re   r  ÚopÚop_nameÚomaskÚpd_oprQ   rV   r`   rW   rW   rX   Ú_arith_methodÍ  sn   ÿþ







ÿ€ÿ
€

zBaseMaskedArray._arith_methodrD   c                 C  s(  ddl m} d }t|tƒr|j|j}}nt|ƒr3t |¡}|j	dkr't
dƒ‚t| ƒt|ƒkr3tdƒ‚|tju rKtj| jjdd�}tj| jjdd�}n<t ¡ �0 t dd	t¡ t dd	t¡ t| jd
|j› d
�ƒ}||ƒ}|tu rxt| j||ƒ}W d   ƒ n1 s‚w   Y  |  ||¡}|||dd�S )Nr   rC   r‹   r  zLengths must match to comparer[   rk   rØ   ÚelementwiseÚ__FrŸ   )rþ   rD   r]   rJ   rM   rO   r"   r^   rÔ   rˆ   rq   r“   rd   rÛ   rÜ   r
  rc   rp   rÝ   rÞ   rß   ÚFutureWarningÚDeprecationWarningr  r%  r  r>   r  )re   r  r.  rD   rQ   rV   r„   rW   rW   rX   Ú_cmp_method,  s0   




€ôzBaseMaskedArray._cmp_methodrV   ú*np.ndarray | tuple[np.ndarray, np.ndarray]c           	      C  sü   t |tƒr|\}}|  ||¡|  ||¡fS |jjdkr(ddlm} |||dd�S |jjdkr;ddlm} |||dd�S t 	|jd¡rdt
|jƒrddd	lm} |j d
¡||< t ||ƒsb|j||jd�S |S |jjdv rwddlm} |||dd�S tj||< |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r¢   r   rG   FrŸ   r¡   rC   r  )ÚTimedeltaArrayrí   rk   rî   ©rý   )r]   r  rÌ   r`   r£   rþ   rH   rD   r   Úis_np_dtyper
   r9  rn   rY   rý   r^   rñ   )	re   rV   rQ   Údivr"  rH   rD   r9  rý   rW   rW   rX   rÌ   T  s,   
	

þ

z"BaseMaskedArray._maybe_mask_resultc                 C  r  rS   )rO   rZ   ry   rW   rW   rX   r)   ƒ  r·   zBaseMaskedArray.isnac                 C  r¸   rS   ré   ry   rW   rW   rX   r  †  rz   zBaseMaskedArray._na_valuec                 C  s   | j j| jj S rS   )rM   ÚnbytesrO   ry   rW   rW   rX   r=  Š  s   zBaseMaskedArray.nbytesÚ	to_concatúSequence[Self]c                 C  s:   t jdd„ |D ƒ|d�}t jdd„ |D ƒ|d�}| ||ƒS )Nc                 S  ó   g | ]}|j ‘qS rW   ©rM   rå   rW   rW   rX   rè   ”  ó    z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r¿   c                 S  r@  rW   )rO   rå   rW   rW   rX   rè   •  rB  )r^   Úconcatenate)rU   r>  r½   r¼   rQ   rW   rW   rX   Ú_concat_same_typeŽ  s   
z!BaseMaskedArray._concat_same_typeÚencodingÚhash_keyÚ
categorizeúnpt.NDArray[np.uint64]c                C  s*   t | j|||d�}t| jjƒ||  ¡ < |S )N)rE  rF  rG  )r?   rM   Úhashr`   r€   r)   )re   rE  rF  rG  Úhashed_arrayrW   rW   rX   Ú_hash_pandas_object˜  s
   
ÿz#BaseMaskedArray._hash_pandas_object)Ú
allow_fillÚ
fill_valuer½   rL  rM  úScalar | Nonec          	      C  sp   t |ƒr| jn|}t| j||||d�}t| j|d||d�}|r2t|ƒr2t |¡dk}|||< ||A }|  ||¡S )N)rM  rL  r½   TrŠ   )	r)   rK   r3   rM   rO   r*   r^   rÔ   rY   )	re   ÚindexerrL  rM  r½   Údata_fill_valuerV   rQ   Ú	fill_maskrW   rW   rX   r3   ¡  s    
ûÿzBaseMaskedArray.takec                   sr   ddl m} t |¡}tˆ j|ƒ}ˆ jr)|jtko#t	‡ fdd„|D ƒƒ}||ˆ j
< tjˆ jjtd�}|||dd�S )Nr   rC   c                 3  s   � | ]	}|ˆ j ju V  qd S rS   ré   )ræ   r±   ry   rW   rX   r  Î  s   € 
ÿz'BaseMaskedArray.isin.<locals>.<genexpr>rk   FrŸ   )rþ   rD   r^   rÔ   r0   rM   r®   r`   rÕ   rŽ   rO   r
  rc   r[   )re   rP   rD   Ú
values_arrrV   Úvalues_have_NArQ   rW   ry   rX   r0   Å  s   
ÿ
zBaseMaskedArray.isinc                 C  s    | j  ¡ }| j ¡ }|  ||¡S rS   )rM   rZ   rO   rY   )re   r¼   rQ   rW   rW   rX   rZ   Ù  s   

zBaseMaskedArray.copyr˜   ÚkeepúLiteral['first', 'last', False]c                 C  s   | j }| j}tj|||d�S )N)rT  rQ   )rM   rO   ÚalgosÚ
duplicated)re   rT  rP   rQ   rW   rW   rX   rW  Þ  s   zBaseMaskedArray.duplicatedc                 C  s    t  | j| j¡\}}|  ||¡S )z‚
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rV  Úunique_with_maskrM   rO   rY   )re   ÚuniquesrQ   rW   rW   rX   Úuniqueæ  s   zBaseMaskedArray.uniqueÚleftr�   ú$NumpyValueArrayLike | ExtensionArrayÚsideúLiteral['left', 'right']ÚsorterúNumpySorter | Noneúnpt.NDArray[np.intp] | np.intpc                 C  s4   | j rtdƒ‚t|tƒr| t¡}| jj|||d�S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)r]  r_  )r®   rd   r]   r9   rá   rÕ   rM   Úsearchsorted)re   r�   r]  r_  rW   rW   rX   rb  ñ  s   ÿ

zBaseMaskedArray.searchsortedÚuse_na_sentinelú!tuple[np.ndarray, ExtensionArray]c                 C  sò   | j }| j}t|d|d�\}}|j| jjksJ |j| jfƒ‚| ¡ }|s&|s+t|ƒ}nt|ƒd }tj|t	d�}|so|ro| 
¡ }	|	dkrJt d¡}
n
|d |	…  ¡ d }
|||
k  d7  < |
||dk< t ||
d¡}d||
< |  ||¡}||fS )NT)rc  rQ   r‹   rk   r   rŠ   )rM   rO   r/   r`   rï   rŽ   r“   r^   r
  r[   r’   ÚintpÚmaxÚinsertrY   )re   rc  ÚarrrQ   ÚcodesrY  Úhas_naÚsizeÚuniques_maskÚna_indexÚna_codeÚ
uniques_earW   rW   rX   Ú	factorize  s(   
zBaseMaskedArray.factorizec                 C  s   | j S rS   rA  ry   rW   rW   rX   Ú_values_for_argsort'  s   z#BaseMaskedArray._values_for_argsortÚdropnarB   c                 C  s’   ddl m}m} ddlm} tj| j|| jd�\}}}t	j
t|ƒft	jd�}| ¡ }	|dkr2d|d< |||	ƒ}
|| j ¡ ||ƒƒ}||
|dd	d
�S )aA  
        Returns a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )ÚIndexrB   r:  ©rr  rQ   rk   TrŠ   ÚcountF)ÚindexÚnamerZ   )Úpandasrs  rB   Úpandas.arraysrý   rV  Úvalue_counts_arraylikerM   rO   r^   r
  r“   ra   rZ   r`   rð   )re   rr  rs  rB   rý   ÚkeysÚvalue_countsÚ
na_counterÚ
mask_indexrQ   rh  rv  rW   rW   rX   r|  +  s    
ÿ
ÿÿzBaseMaskedArray.value_countsc                 C  sZ   |rt | j|| jd�}tj|jtjd�}nt | j|| jd�\}}t| ƒ||ƒ}|| ¡  S )Nrt  rk   )	r2   rM   rO   r^   r
  rc   ra   rn   Úargsort)re   rr  rV   Úres_maskrW   rW   rX   Ú_modeS  s   zBaseMaskedArray._modec                 C  sd   t | ƒt |ƒkr
dS |j| jkrdS t | j|j¡sdS | j| j  }|j|j  }t||ddd�S )NFT)Ú
strict_nanÚdtype_equal)rn   r`   r^   Úarray_equalrO   rM   r'   )re   r  r[  ÚrightrW   rW   rX   Úequals\  s   zBaseMaskedArray.equalsÚqsúnpt.NDArray[np.float64]Úinterpolationc                 C  s˜   t | j| jtj||d�}| jr=| jdkrt‚|  ¡  	¡ r4tj
|jtd�}t| jƒr3tj|j| jjd�}ntj|jtd�}ntj|jtd�}| j||d�S )z½
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rQ   rM  r‡  r‰  é   rk   r  )r6   rM   rO   r^   rñ   r®   rˆ   rq   r)   r‘   rp   rc   r[   r!   r`   r
  rï   rÌ   )re   r‡  r‰  ÚresÚout_maskrW   rW   rX   Ú	_quantilel  s$   ù


€zBaseMaskedArray._quantile)ÚskipnaÚkeepdimsrw  rŽ  r�  c          
      K  s´   |dv rt | |ƒdd|i|¤Ž}n | j}| j}t td|› �ƒ}| dd ¡}	||f|	||dœ|¤Ž}|rQt|ƒr?| j|ddd�S | d	¡}tj	d	t
d
�}|  ||¡S t|ƒrXtjS |S )N>	   r‘   rŽ   rf  ÚminÚstdÚsumÚvarÚmeanÚprodrŽ  rñ   r½   )r½   rŽ  rQ   r   )r‹   )rw  r½   Ú	mask_sizer‹   rk   rW   )r  rM   rO   r-   Úpopr)   Ú_wrap_na_resultrÃ   r^   r
  r[   rÌ   rÛ   rÜ   )
re   rw  rŽ  r�  rÆ   rV   r¼   rQ   r.  r½   rW   rW   rX   Ú_reduce˜  s    
zBaseMaskedArray._reducec                C  s>   t |tjƒr|r| jj|d�}n| jj|d�}|  ||¡S |S r¾   )r]   r^   r_   rO   r‘   rŽ   rÌ   )re   rw  rV   rŽ  r½   rQ   rW   rW   rX   Ú_wrap_reduction_result²  s   z&BaseMaskedArray._wrap_reduction_resultc                C  s¦   t j|td�}| jdkrdnd}|dv r|}n-|dv s!| jjdkr'| jjj}ntƒ p,t }|r1dnd	}|r7d
nd}	|||	|dœ| jj	 }t j
dg|d�}
| j|
|d�S )Nrk   ÚFloat32r   r+  )r”  Úmedianr“  r‘  ÚskewÚkurt)r�  rf  é   Úint32Úint64Úuint32Úuint64)r¡   r³   Úur¢   r‹   r  )r^   rp   r[   r`   Úitemsizerï   rw  r   r   r£   r:   rÌ   )re   rw  r½   r–  rQ   Ú
float_dtypÚnp_dtypeÚis_windows_or_32bitÚint_dtypÚ	uint_dtypr�   rW   rW   rX   r˜  ½  s   ÿzBaseMaskedArray._wrap_na_resultc                C  s>   |dkrt |tjƒr|  |tj|jtd�¡S | j||||d�S )Nr   rk   ©rŽ  r½   )r]   r^   r_   rÌ   r
  rc   r[   rš  )re   rw  rV   rŽ  Ú	min_countr½   rW   rW   rX   Ú _wrap_min_count_reduction_resultÐ  s   z0BaseMaskedArray._wrap_min_count_reduction_result©rŽ  r¬  r½   r¬  úAxisInt | Nonec                K  ó8   t  d|¡ tj| j| j|||d�}| jd||||d�S )NrW   r®  r’  )rÉ   Úvalidate_sumr5   r’  rM   rO   r­  ©re   rŽ  r¬  r½   rÆ   rV   rW   rW   rX   r’  ×  ó   û
ÿzBaseMaskedArray.sumc                K  r°  )NrW   r®  r•  )rÉ   Úvalidate_prodr5   r•  rM   rO   r­  r²  rW   rW   rX   r•  ì  r³  zBaseMaskedArray.prodr«  c                K  ó4   t  d|¡ tj| j| j||d�}| jd|||d�S )NrW   r«  r”  )rÉ   Úvalidate_meanr5   r”  rM   rO   rš  ©re   rŽ  r½   rÆ   rV   rW   rW   rX   r”    ó   üzBaseMaskedArray.meanr‹   ©rŽ  r½   Úddofrº  c                K  ó:   t jd|dd� tj| j| j|||d�}| jd|||d�S )NrW   r“  ©Úfnamer¹  r«  )rÉ   Úvalidate_stat_ddof_funcr5   r“  rM   rO   rš  ©re   rŽ  r½   rº  rÆ   rV   rW   rW   rX   r“    ó   ûzBaseMaskedArray.varc                K  r»  )NrW   r‘  r¼  r¹  r«  )rÉ   r¾  r5   r‘  rM   rO   rš  r¿  rW   rW   rX   r‘    rÀ  zBaseMaskedArray.stdc                K  rµ  )NrW   r«  r�  )rÉ   Úvalidate_minr5   r�  rM   rO   rš  r·  rW   rW   rX   r�  %  r¸  zBaseMaskedArray.minc                K  rµ  )NrW   r«  rf  )rÉ   Úvalidate_maxr5   rf  rM   rO   rš  r·  rW   rW   rX   rf  /  r¸  zBaseMaskedArray.maxc                 C  s   t |  ¡ ||d�S )N)Ú	na_action)r1   rã   )re   ÚmapperrÃ  rW   rW   rX   Úmap9  s   zBaseMaskedArray.mapc                K  s^   t  d|¡ | j ¡ }t || j| j¡ | ¡ }|r|S |s)t	| ƒdks)| j ¡ s+|S | j
jS )aY  
        Return whether any element is truthy.

        Returns False unless there is at least one element that is truthy.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be False, as for an empty array.
            If `skipna` is False, the result will still be True if there is
            at least one element that is truthy, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.any : Numpy version of this method.
        BaseMaskedArray.all : Return whether all elements are truthy.

        Examples
        --------
        The result indicates whether any element is truthy (and by default
        skips NAs):

        >>> pd.array([True, False, True]).any()
        True
        >>> pd.array([True, False, pd.NA]).any()
        True
        >>> pd.array([False, False, pd.NA]).any()
        False
        >>> pd.array([], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="Float64").any()
        False

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        rW   r   )rÉ   Úvalidate_anyrM   rZ   r^   ÚputmaskrO   Ú_falsey_valuerŽ   r“   r`   r€   ©re   rŽ  r½   rÆ   rP   rV   rW   rW   rX   rŽ   <  s   ?
zBaseMaskedArray.anyc                K  sb   t  d|¡ | j ¡ }t || j| j¡ |j|d�}|r|S |r+t	| ƒdks+| j 
¡ s-|S | jjS )aL  
        Return whether all elements are truthy.

        Returns True unless there is at least one element that is falsey.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be True, as for an empty array.
            If `skipna` is False, the result will still be False if there is
            at least one element that is falsey, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.all : Numpy version of this method.
        BooleanArray.any : Return whether any element is truthy.

        Examples
        --------
        The result indicates whether all elements are truthy (and by default
        skips NAs):

        >>> pd.array([True, True, pd.NA]).all()
        True
        >>> pd.array([1, 1, pd.NA]).all()
        True
        >>> pd.array([True, False, pd.NA]).all()
        False
        >>> pd.array([], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="Float64").all()
        True

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        rW   r¿   r   )rÉ   Úvalidate_allrM   rZ   r^   rÇ  rO   Ú_truthy_valuer‘   r“   rŽ   r`   r€   rÉ  rW   rW   rX   r‘   �  s   ?
zBaseMaskedArray.allr   rH   c             
   K  sÊ   | j jdkr|r| j ¡ }	| j ¡ }
n#| j}	| j}
n| j jdv r.d}| j d¡}	| j ¡ }
ntd| j › �ƒ‚tj|	f|d|||||
dœ|¤Ž |sK| S | j jdkrYt	| ƒ 
|	|
¡S ddlm} | 
|	|
¡S )	z2
        See NDFrame.interpolate.__doc__.
        r¢   rî   TÚf8z)interpolate is not implemented for dtype=r   )r„   r½   rv  r‚   Úlimit_directionrƒ   rQ   rG   )r`   r£   rM   rZ   rO   rá   rq   r	   Úinterpolate_2d_inplacern   rY   rþ   rH   )re   r„   r½   rv  r‚   rÍ  rƒ   rZ   rÆ   r¼   rQ   rH   rW   rW   rX   Úinterpolateß  s@   

ÿÿø	÷zBaseMaskedArray.interpolate)rŽ  c                K  s<   | j }| j}tt|ƒ}|||fd|i|¤Ž\}}|  ||¡S )NrŽ  )rM   rO   r  r4   rY   )re   rw  rŽ  rÆ   r¼   rQ   r.  rW   rW   rX   Ú_accumulate  s
   
zBaseMaskedArray._accumulateÚhowÚhas_dropped_naÚngroupsÚidsúnpt.NDArray[np.intp]c                K  sÔ   ddl m} | |¡}||||d�}	| j}
|	jdkr|
 ¡ }ntj|td�}|dkr7| 	d¡dv r7d	|d d …< |	j
| jf||||
|d
œ|¤Ž}|	jdkr]|	j 	|	jd¡}t ||df¡j}|	jdv rd|S |  ||¡S )Nr   )ÚWrappedCythonOp)rÑ  r£   rÒ  Ú	aggregaterk   ÚrankÚ	na_option)ÚtopÚbottomF)r¬  rÓ  Úcomp_idsrQ   Úresult_maskÚohlcr‹   )ÚidxminÚidxmax)Úpandas.core.groupby.opsrÖ  Úget_kind_from_howrO   r£   rZ   r^   r
  r[   r  Ú_cython_op_ndim_compatrM   rÑ  Ú_cython_arityÚtiler�   rÌ   )re   rÑ  rÒ  r¬  rÓ  rÔ  rÆ   rÖ  r£   r.  rQ   rÝ  Ú
res_valuesÚarityrW   rW   rX   Ú_groupby_op!  s4   



ÿúù


zBaseMaskedArray._groupby_op)rP   rL   rQ   rN   rR   r   )F)rP   rL   rQ   rN   rZ   r[   rR   r\   )rZ   r[   rR   r   )rc   r   r`   r   )rs   r[   rR   rt   )rR   r&   )r{   r   rR   r   )r{   r   rR   r   )r{   r   rR   r   )
r„   r   r‚   r…   rƒ   r†   rZ   r[   rR   r   )NNNT)r‚   r…   rZ   r[   rR   r   )r`   r   rZ   r[   rR   r    )rR   r\   )rR   r[   )rR   r@   )rR   rµ   )rR   r   )rR   r   )r   )r½   r   rR   r   )rÈ   rµ   )rR   rL   )r`   r×   rZ   r[   r€   rÕ   rR   rL   ).)r`   rê   rZ   r[   rR   rL   )r`   r   rZ   r[   rR   r9   )r`   r   rZ   r[   rR   r   )T)NN)r`   rõ   rZ   rö   rR   rL   )rù   rú   r„   ru   rS   )rQ   r  rR   rN   )rR   rD   )rV   r8  rQ   rL   )r>  r?  r½   r   rR   r   )rE  ru   rF  ru   rG  r[   rR   rH  )rL  r[   rM  rN  r½   r   rR   r   )rP   r   rR   rD   )r˜   )rT  rU  rR   rN   )r[  N)r�   r\  r]  r^  r_  r`  rR   ra  )rc  r[   rR   rd  )rr  r[   rR   rB   )rr  r[   rR   r   )r‡  rˆ  r‰  ru   rR   rJ   )rw  ru   rŽ  r[   r�  r[   )rw  ru   )rŽ  r[   r¬  rµ   r½   r¯  )rŽ  r[   r½   r¯  )rŽ  r[   r½   r¯  rº  rµ   )r„   r   r½   rµ   rZ   r[   rR   rH   )rw  ru   rŽ  r[   rR   rJ   )
rÑ  ru   rÒ  r[   r¬  rµ   rÓ  rµ   rÔ  rÕ  )[r%  Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   rË  rÈ  ÚclassmethodrY   rf   rj   r   r9   rr   rv   Úpropertyr`   r   r~   r›   rž   rh   r¦   r¨   r«   r´   r¶   rc   rˆ   r¹   rÀ   rÃ   rÇ   r�   rË   rÎ   rÐ   rÑ   rÓ   rÖ   r   ró   rã   rä   rá   Ú__array_priority__r÷   r  r  r®   r  r2  Ú_logical_methodr7  rÌ   r)   r  r=  rD  rK  r3   r0   rZ   rW  rZ  rb  rp  rq  r|  r�  r†  r�  r™  rš  r˜  r­  r’  r•  r”  r“  r‘  r�  rf  rÅ  rŽ   r‘   rÏ  rÐ  rè  Ú__classcell__rW   rW   r¬   rX   rJ   k   s  
 ÿú,ÿ!ÿ#ü]
.ÿ	M](/
ý	ú$ÿüþ$(	-ÿ
ûûÿÿ

QR5ÿrJ   Úmasked_arraysúSequence[BaseMaskedArray]rR   úlist[BaseMaskedArray]c           
      C  sÈ   t | ƒ} | d j}dd„ | D ƒ}tj|dtjt| ƒt| d ƒfd|jd�d�}dd„ | D ƒ}tj|dtj|td�d�}| 	¡ }g }t
|jd	 ƒD ]}||d
d
…|f |d
d
…|f d�}	| |	¡ qH|S )zÖTranspose masked arrays in a list, but faster.

    Input should be a list of 1-dim masked arrays of equal length and all have the
    same dtype. The caller is responsible for ensuring validity of input data.
    r   c                 S  ó   g | ]	}|j  d d¡‘qS ©r‹   rŠ   )rM   rÃ   ©ræ   rh  rW   rW   rX   rè   \  ó    z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>ÚF)Úorderr`   )r½   rû   c                 S  rõ  rö  )rO   rÃ   r÷  rW   rW   rX   rè   g  rø  rk   r‹   Nr  )Úlistr`   r^   rC  rm   r“   rï   Ú
empty_liker[   rð   r°   rc   r  )
rò  r`   rP   Útransposed_valuesÚmasksÚtransposed_masksÚarr_typeÚtransposed_arraysr³   Útransposed_arrrW   rW   rX   Ú#transpose_homogeneous_masked_arraysQ  s,   
ýý
ÿ$r  )rò  ró  rR   rô  )jÚ
__future__r   Útypingr   r   r   r   r   rÝ   Únumpyr^   Úpandas._libsr   r	   rÛ   Úpandas._libs.tslibsr
   Úpandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   Úpandas.compatr   r   Úpandas.errorsr   Úpandas.util._decoratorsr   Úpandas.util._validatorsr   Úpandas.core.dtypes.baser   Úpandas.core.dtypes.commonr    r!   r"   r#   r$   r%   Úpandas.core.dtypes.dtypesr&   Úpandas.core.dtypes.missingr'   r(   r)   r*   Úpandas.corer+   rV  r,   r-   r.   Úpandas.core.algorithmsr/   r0   r1   r2   r3   Úpandas.core.array_algosr4   r5   Ú pandas.core.array_algos.quantiler6   Úpandas.core.arrayliker7   Úpandas.core.arrays._utilsr8   Úpandas.core.arrays.baser9   Úpandas.core.constructionr:   r'  r;   r<   Úpandas.core.indexersr=   Úpandas.core.opsr>   Úpandas.core.util.hashingr?   Úcollections.abcr@   rA   rx  rB   rþ   rD   rE   rF   rH   Úpandas.compat.numpyrI   rÉ   rJ   r  rW   rW   rW   rX   Ú<module>   s\    @            q