a
    DBìjÝ  ã                   @  sP  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, d dl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z: d dl;m<Z=m>Z>mZm?Z?m@Z@ d dlAmBZBmCZCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZTmUZUmVZV d dlWmXZX d dlYmZZZ d dl[m\Z\ e�rd dl]m^Z^m_Z_ d dl`maZa d dlbmcZc d dlmdZdmeZe d dlbmfZf d d lgmhZi G d!d"„ d"eMeQƒZjd#d$d%œd&d'„Zkd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)Úfind_stack_level)Ú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                      sh  e Zd ZU dZded< ded< ded< eZeZedddd	œd
d„ƒZ	�ddddddœdd„Z
edddœdddœdd„ƒZeeejƒdddœdd„ƒƒZ�ddddœdd„Zed d!œd"d#„ƒZed$d%d&œd'd(„ƒZed)dd&œd*d(„ƒZd+d,d&œd-d(„Zddd.d/œd0d1d2ddd3œd4d5„Zeejƒ�dd1ddd6œd7d8„ƒZedd9œd:dd;d<œd=d>„ƒZd?d@„ Zdd!œdAdB„Zdd!œ‡ fdCdD„ZdEd!œdFdG„ZdHd!œdIdJ„Zedd!œdKdL„ƒZedHd!œdMdN„ƒZdd!œdOdP„Z�ddRddSœdTdU„Zdd!œdVdW„Z dd!œdXdY„Z!edd!œdZd[„ƒZ"�ddHd\œd]d^„Z#dd!œd_d`„Z$dd!œdadb„Z%dd!œdcdd„Z&dd!œdedf„Z'dd!œdgdh„Z(dde)j*fdiddjddkœdldm„Z+eej,ƒdndo„ ƒZ,e�ddqddd<œdrds„ƒZ-e�ddddtd<œduds„ƒZ-e�ddvddwd<œdxds„ƒZ-�d	dvddwd<œdyds„Z-dzZ.�d
d{d|dd<œd}d~„Z/ded€< d�d‚dƒœd„d…„Z0�dd†d‡„Z1edd!œdˆd‰„ƒZ2dŠdd‹œdŒd�„Z3dŽd�„ Z4e4Z5d�d!œd‘d’„Z6d“dd”œd•d–„Z7dd!œd—d˜„Z8ed™dš„ ƒZ9edHd!œd›dœ„ƒZ:e�dd�dRddžœdŸd „ƒZ;d‚d‚dd¡d¢œd£d¤„Z<dddQd¥œdd¦dRdd§œd¨d©„Z=dwd�dªœd«d¬„Z>dd!œd­d®„Z?eej@ƒ�dd°dd±œd²d³„ƒZ@dd!œd´dµ„ZAeejBƒ�dd·d¸d¹dºd»œd¼d½„ƒZBeejCƒ�ddd¾d¿œdÀdÁ„ƒZCeejDƒdd!œdÂdÃ„ƒZD�dddÄdÅœdÆdÇ„ZE�ddddÅœdÈdÉ„ZFeejGƒdd!œdÊdË„ƒZGdÌd‚d dÍœdÎdÏ„ZHd.ddÐœd‚dddÑœdÒdÓ„ZId‚dÔœdÕdÖ„ZJd×dØ„ ZKd‚dÔœdÙdÚ„ZLd.dQdQdÛœddHdÜdÛœdÝdÞ„ZMd.dQdQdÛœddHdÜdÛœdßdà„ZNd.dQdáœddÜdáœdâdã„ZOd.dQdädåœddÜdHdåœdædç„ZPd.dQdädåœddÜdHdåœdèdé„ZQd.dQdáœddÜdáœdêdë„ZRd.dQdáœddÜdáœdìdí„ZS�ddîdï„ZTd.dQdáœddÜdáœdðdñ„ZUd.dQdáœddÜdáœdòdó„ZVdôdHddõdöœd÷dø„ZWd.dùœd‚dd dúœdûdü„ZXd‚ddHdHdýdþœdÿ�d „ZY‡  ZZS (  ÚBaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   Ú_internal_fill_valueú
np.ndarrayÚ_dataznpt.NDArray[np.bool_]Ú_maskr   )ÚvaluesÚmaskÚreturnc                 C  s   t  | ¡}||_||_|S ©N)rK   Ú__new__rN   rO   )ÚclsrP   rQ   Úresult© rW   úX/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/core/arrays/masked.pyÚ_simple_new}   s    
zBaseMaskedArray._simple_newFÚboolÚNone)rP   rQ   ÚcopyrR   c                 C  sX   t |tjƒr|jtjks tdƒ‚|j|jkr4tdƒ‚|rH| ¡ }| ¡ }|| _	|| _
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Ú
ValueErrorr\   rN   rO   )ÚselfrP   rQ   r\   rW   rW   rX   Ú__init__„   s    ÿzBaseMaskedArray.__init__N©r`   r\   )r\   rR   c                C  s   | j |||d�\}}| ||ƒS )Nrg   )Ú_coerce_to_array)rU   Zscalarsr`   r\   rP   rQ   rW   rW   rX   Ú_from_sequence—   s    zBaseMaskedArray._from_sequencer   r    )rc   r`   c                 C  s\   t j||jd�}| | j¡ t j|td�}| ||ƒ}t|| ƒrH||jkrXt	d|› d�ƒ‚|S )N©r`   z5Default 'empty' implementation is invalid for dtype='ú')
r^   ÚemptyÚtypeÚfillrL   ÚonesrZ   r]   r`   ÚNotImplementedError)rU   rc   r`   rP   rQ   rV   rW   rW   rX   Ú_emptyœ   s    

ÿzBaseMaskedArray._emptyzCallable[[Any], str | None])ÚboxedrR   c                 C  s   t S rS   )Ústr)re   rr   rW   rW   rX   Ú
_formatter©   s    zBaseMaskedArray._formatterr'   )rR   c                 C  s   t | ƒ‚d S rS   r   ©re   rW   rW   rX   r`   ­   s    zBaseMaskedArray.dtyper   r   )ÚitemrR   c                 C  s   d S rS   rW   ©re   rv   rW   rW   rX   Ú__getitem__±   s    zBaseMaskedArray.__getitem__r   c                 C  s   d S rS   rW   rw   rW   rW   rX   rx   µ   s    r   z
Self | Anyc                 C  sD   t | |ƒ}| j| }t|ƒr2|r(| jjS | j| S |  | j| |¡S rS   )r>   rO   r!   r`   Úna_valuerN   rY   )re   rv   ZnewmaskrW   rW   rX   rx   ¹   s    


T)ÚlimitÚ
limit_arear\   r   z
int | Nonez#Literal['inside', 'outside'] | None)Úmethodrz   r{   r\   rR   c                C  sT  | j }| ¡ �r<tj|| jd�}| jj}|j}|rD| ¡ }| ¡ }n|d urT| ¡ }||||d� |d u�r | ¡ �s |j}| }	|	 	¡ }
t
|	ƒ|	d d d…  	¡  d }|dkrò|d |
…  |d |
… O  < ||d d …  ||d d … O  < n.|dk�r ||
d |…  ||
d |… O  < |�r6|  |j|j¡S | S n|�rL|  ¡ }n| }|S )N©Úndim©rz   rQ   éÿÿÿÿé   ZinsideZoutside)rO   Úanyr	   Úget_fill_funcr~   rN   ÚTr\   ÚallÚargmaxÚlenrY   )re   r|   rz   r{   r\   rQ   ÚfuncÚnpvaluesÚnew_maskZneg_maskÚfirstÚlastÚ
new_valuesrW   rW   rX   Ú_pad_or_backfillÅ   s8    

&
$
z BaseMaskedArray._pad_or_backfill)rz   r\   rR   c           
      C  sÈ   t ||ƒ\}}| j}t ||t| ƒ¡}| ¡ rª|d ur†tj|| jd�}| jj	}|j	}|rh| 
¡ }| 
¡ }||||d� |  |j	|j	¡S |r”|  
¡ }	n| d d … }	||	|< n|r¸|  
¡ }	n| d d … }	|	S )Nr}   r   )r   rO   r	   Zcheck_value_sizer‡   r‚   rƒ   r~   rN   r„   r\   rY   )
re   Úvaluer|   rz   r\   rQ   rˆ   r‰   rŠ   r�   rW   rW   rX   Úfillnañ   s*    


zBaseMaskedArray.fillna©r\   r   ztuple[np.ndarray, np.ndarray])r`   r\   rR   c                C  s   t | ƒ‚d S rS   r   )rU   rP   r`   r\   rW   rW   rX   rh     s    z BaseMaskedArray._coerce_to_arrayc                 C  s~   | j j}|dkr t |¡rb|S nB|dkrBt |¡s<t |¡rb|S n t |¡s^t |¡rb| ¡ rb|S td|›d| j › d�ƒ‚dS )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        ÚbÚfzInvalid value 'z' for dtype 'rk   N)r`   Úkindr   r!   Ú
is_integerÚis_floatrb   )re   r�   r”   rW   rW   rX   Ú_validate_setitem_value  s    
z'BaseMaskedArray._validate_setitem_valuec                 C  sx   t | |ƒ}t|ƒrLt|| jƒr*d| j|< n|  |¡}|| j|< d| j|< d S | j|| jd�\}}|| j|< || j|< d S )NTFrj   )r>   r$   r)   r`   rO   r—   rN   rh   )re   Úkeyr�   rQ   rW   rW   rX   Ú__setitem__4  s    




zBaseMaskedArray.__setitem__c                   sX   t |ƒrH|| jjurH| jjjdkrHt |¡rHtt 	| j¡| j
 @  ¡ ƒS ttƒ  |¡ƒS )Nr“   )r*   r`   ry   rN   r”   r   r–   rZ   r^   ÚisnanrO   r‚   ÚsuperÚ__contains__)re   r˜   ©Ú	__class__rW   rX   rœ   E  s    zBaseMaskedArray.__contains__rA   c                 c  sx   | j dkrX| js$| jD ]
}|V  qqt| jj}t| j| jƒD ]\}}|rN|V  q:|V  q:ntt| ƒƒD ]}| | V  qdd S )Nr�   )	r~   Ú_hasnarN   r`   ry   ÚziprO   Úranger‡   )re   Úvalry   Zisna_ÚirW   rW   rX   Ú__iter__M  s    



zBaseMaskedArray.__iter__Úintc                 C  s
   t | jƒS rS   )r‡   rN   ru   rW   rW   rX   Ú__len__]  s    zBaseMaskedArray.__len__c                 C  s   | j jS rS   )rN   rc   ru   rW   rW   rX   rc   `  s    zBaseMaskedArray.shapec                 C  s   | j jS rS   )rN   r~   ru   rW   rW   rX   r~   d  s    zBaseMaskedArray.ndimc                 C  s(   | j  ||¡}| j ||¡}|  ||¡S rS   )rN   ÚswapaxesrO   rY   )re   Zaxis1Zaxis2ÚdatarQ   rW   rW   rX   r§   h  s    zBaseMaskedArray.swapaxesr   r   )ÚaxisrR   c                 C  s0   t j| j||d�}t j| j||d�}|  ||¡S ©N©r©   )r^   ÚdeleterN   rO   rY   )re   Úlocr©   r¨   rQ   rW   rW   rX   r¬   m  s    zBaseMaskedArray.deletec                 O  s0   | j j|i |¤Ž}| jj|i |¤Ž}|  ||¡S rS   )rN   ÚreshaperO   rY   ©re   ÚargsÚkwargsr¨   rQ   rW   rW   rX   r®   r  s    zBaseMaskedArray.reshapec                 O  s2   | j j|i |¤Ž}| jj|i |¤Ž}t| ƒ||ƒS rS   )rN   ÚravelrO   rm   r¯   rW   rW   rX   r²   w  s    zBaseMaskedArray.ravelc                 C  s   |   | jj| jj¡S rS   )rY   rN   r„   rO   ru   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”   ÚnvZvalidate_roundr^   ÚroundrN   Ú_maybe_mask_resultrO   r\   )re   r³   r°   r±   rP   rW   rW   rX   rµ   �  s
    zBaseMaskedArray.roundc                 C  s   |   | j | j ¡ ¡S rS   ©rY   rN   rO   r\   ru   rW   rW   rX   Ú
__invert__¤  s    zBaseMaskedArray.__invert__c                 C  s   |   | j | j ¡ ¡S rS   r·   ru   rW   rW   rX   Ú__neg__§  s    zBaseMaskedArray.__neg__c                 C  s   |   ¡ S rS   r‘   ru   rW   rW   rX   Ú__pos__ª  s    zBaseMaskedArray.__pos__c                 C  s   |   t| jƒ| j ¡ ¡S rS   )rY   ÚabsrN   rO   r\   ru   rW   rW   rX   Ú__abs__­  s    zBaseMaskedArray.__abs__c                 C  s   t j| td�S )Nrj   )r^   ÚasarrayÚobjectru   rW   rW   rX   Ú_values_for_json²  s    z BaseMaskedArray._values_for_jsonznpt.DTypeLike | Noner¾   )r`   r\   ry   rR   c                 C  sê   | j }t| |||ƒ\}}|du r$t}|r |tkrRt|ƒsR|tju rRtd|› d�ƒ‚t ¡ �* tj	dt
d� | j |¡}W d  ƒ n1 sŠ0    Y  ||| j< nFt ¡ �. tj	dt
d� | jj||d�}W d  ƒ n1 sÜ0    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Ÿ   r9   r¾   r%   Ú
libmissingÚNArd   ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrN   ÚastyperO   )re   r`   r\   ry   Zhasnar¨   rW   rW   rX   Úto_numpyµ  s,    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>  ó    z*BaseMaskedArray.tolist.<locals>.<listcomp>©r`   ry   )r~   rŸ   rN   r`   rÊ   rÃ   rÄ   rË   )re   r`   rW   rW   rX   rË     s    
zBaseMaskedArray.tolist.znpt.DTypeLikec                 C  s   d S rS   rW   ©re   r`   r\   rW   rW   rX   rÉ     s    zBaseMaskedArray.astyper:   c                 C  s   d S rS   rW   rÒ   rW   rW   rX   rÉ     s    r   r   c                 C  s   d S rS   rW   rÒ   rW   rW   rX   rÉ   !  s    c                 C  s@  t |ƒ}|| jkr"|r|  ¡ S | S t|tƒr¤t ¡ �0 tjdtd� | j	j
|j|d�}W d   ƒ n1 sj0    Y  || j	u r„| jn| j ¡ }| ¡ }|||dd�S t|tƒrÆ| ¡ }|j| ||d�S |jdkrØtj}n|jdkrît 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`   ry   r\   )r&   r`   r\   r]   r'   rÅ   rÆ   rÇ   rÈ   rN   rÉ   Únumpy_dtyperO   Úconstruct_array_typer    ri   r”   r^   ÚnanZ
datetime64r   Ú
no_defaultrŸ   rd   rÊ   )re   r`   r\   r¨   rQ   rU   Zeaclsry   rW   rW   rX   rÉ   %  s4    


0


iè  zNpDtype | Nonezbool | Nonec                 C  sL   |du r2| j s tj| j||d�S tjdttƒ d� |du r>d}| j||d�S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        Frg   aS  Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.)Ú
stacklevelN)	rŸ   r^   r;   rN   rÅ   ÚwarnÚFutureWarningr   rÊ   rÒ   rW   rW   rX   Ú	__array__U  s    øzBaseMaskedArray.__array__ztuple[type, ...]Ú_HANDLED_TYPESznp.ufuncrs   )Úufuncr|   c           	        sp  |  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r°tj| ||g|¢R i |¤Ž}|tur°|S t	j
t| ƒtd�‰ g }|D ]0}t|tƒrðˆ |jO ‰ | |j¡ qÊ| |¡ qÊddœ‡ fdd„‰t||ƒ|i |¤Ž}|jd	k�rDt‡fd
d„|D ƒƒS |dk�rd| j ¡ �r`| jS |S ˆ|ƒS d S )NÚoutrW   Úreducerj   rM   )rÎ   c                   s”   ddl m}m}m} | jjdkr2ˆ  ¡ }|| |ƒS | jjdv rPˆ  ¡ }|| |ƒS | jjdkr†ˆ  ¡ }| jtjkr||  	tj
¡} || |ƒS tj| ˆ < | S )Nr   )rE   rI   ÚIntegerArrayr’   rÕ   r“   )Úpandas.core.arraysrE   rI   râ   r`   r”   r\   r^   Zfloat16rÉ   Úfloat32rØ   )rÎ   rE   rI   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>¶  rÐ   z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)Úgetr]   rÞ   rK   ÚNotImplementedr-   Z!maybe_dispatch_ufunc_to_dunder_opZdispatch_ufunc_with_outZdispatch_reduction_ufuncr^   Úzerosr‡   rZ   rO   ÚappendrN   ÚgetattrZnoutÚtupler‚   Ú	_na_value)	re   rß   r|   Úinputsr±   rà   rÎ   rV   Zinputs2rW   )rQ   rç   rX   Ú__array_ufunc__r  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   rm   )Zpyarrowr;   rN   rO   )re   rm   ÚparW   rW   rX   Ú__arrow_array__¿  s    zBaseMaskedArray.__arrow_array__c                 C  s
   | j  ¡ S rS   )rO   r‚   ru   rW   rW   rX   rŸ   Ç  s    zBaseMaskedArray._hasnaznpt.NDArray[np.bool_] | None)rQ   rR   c                 C  sZ   |d u rL| j  ¡ }|tju r&|dB }qVt|ƒrVt|ƒt|ƒkrV|t|ƒB }n
| j |B }|S )NT)rO   r\   rÃ   rÄ   r#   r‡   r*   )re   rQ   ÚotherrW   rW   rX   Ú_propagate_maskÐ  s    



zBaseMaskedArray._propagate_maskc           	      C  sŽ  |j }d }t|dƒs@t|ƒr@t|ƒt| ƒkr@t|ƒ}t|dd�}t|tƒrZ|j|j	 }}n.t|ƒrˆt|t
ƒsvt |¡}|jdkrˆtdƒ‚t |t| ƒf¡}t |¡}t|ƒ}|dv rÈt|tjƒrÈt|ƒ}|  ||¡}|tju �rZt | j¡}| jjdk�r4|dv �rtd	|› d
�ƒ‚|dv �r$d}nd}| |¡}n$d|v �r°| jjdk�r°| tj¡}nV| jjdv �rv|dv �rv|}tjdd�� || j|ƒ}W d   ƒ n1 �s¦0    Y  |dk�rt | jdk| j	 @ d|¡}|d u�rút |dk| @ d|¡}n|tju�r‚t |dkd|¡}nh|dk�r‚|d u�rHt |dk| @ d|¡}n|tju�rft |dkd|¡}t | jdk| j	 @ d|¡}|  ||¡S )Nr`   T)Zextract_numpyr�   ú(can only perform ops with 1-d structures>   ÚpowÚrpowr’   >   Útruedivrø   Úfloordivr÷   ZrtruedivZ	rfloordivz
operator 'z!' not implemented for bool dtypes>   ÚmodZrmodZint8rZ   rù   r“   rÕ   )rú   rû   rÀ   )r…   r÷   Fr   rø   ) Ú__name__Úhasattrr#   r‡   Úpd_arrayr=   r]   rK   rN   rO   r:   r^   r½   r~   rp   r/   Zmaybe_prepare_scalar_for_opZget_array_opr<   ra   rZ   rõ   rÃ   rÄ   Z	ones_liker`   r”   rÉ   Úfloat64ZerrstateÚwherer¶   )	re   rô   ÚopZop_nameZomaskZpd_oprQ   rV   r`   rW   rW   rX   Ú_arith_methodà  sj    ÿþý







ÿ
,



zBaseMaskedArray._arith_methodrE   c                 C  s*  ddl m} d }t|tƒr*|j|j }}n<t|ƒrft |¡}|j	dkrNt
dƒ‚t| ƒt|ƒkrftdƒ‚|tju r–tj| jjdd�}tj| jjdd�}nzt ¡ �` t dd	t¡ t dd	t¡ t| jd
|j› d
�ƒ}||ƒ}|tu rðt| j||ƒ}W d   ƒ n1 �s0    Y  |  ||¡}|||dd�S )Nr   rD   r�   rö   zLengths must match to comparerZ   rj   rÀ   ZelementwiseÚ__Fr‘   )rã   rE   r]   rK   rN   rO   r#   r^   r½   r~   rp   r‡   rd   rÃ   rÄ   rë   rc   ro   rÅ   rÆ   rÇ   rÜ   ÚDeprecationWarningrí   rü   rê   r?   rõ   )re   rô   r  rE   rQ   rV   r|   rW   rW   rX   Ú_cmp_method?  s,    




.zBaseMaskedArray._cmp_methodz*np.ndarray | tuple[np.ndarray, np.ndarray])rV   rQ   c           	      C  s   t |tƒr*|\}}|  ||¡|  ||¡fS |jjdkrPddlm} |||dd�S |jjdkrvddlm} |||dd�S t 	|jd¡rÈt
|jƒrÈdd	lm} |j d
¡||< t ||ƒsÄ|j||jd�S |S |jjdv rîddlm} |||dd�S tj||< |S dS )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r“   r   rH   Fr‘   r’   rD   rå   )ÚTimedeltaArrayrÔ   rj   rÕ   ©râ   N)r]   rî   r¶   r`   r”   rã   rI   rE   r   Zis_np_dtyper
   r  rm   rY   râ   r^   rØ   )	re   rV   rQ   Údivrû   rI   rE   r  râ   rW   rW   rX   r¶   g  s,    	


þ

z"BaseMaskedArray._maybe_mask_resultc                 C  s
   | j  ¡ S rS   )rO   r\   ru   rW   rW   rX   r*   –  s    zBaseMaskedArray.isnac                 C  s   | j jS rS   rÑ   ru   rW   rW   rX   rï   ™  s    zBaseMaskedArray._na_valuec                 C  s   | j j| jj S rS   )rN   ÚnbytesrO   ru   rW   rW   rX   r	  �  s    zBaseMaskedArray.nbyteszSequence[Self])Ú	to_concatr©   rR   c                 C  s:   t jdd„ |D ƒ|d�}t jdd„ |D ƒ|d�}| ||ƒS )Nc                 S  s   g | ]
}|j ‘qS rW   ©rN   rÌ   rW   rW   rX   rÏ   §  rÐ   z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r«   c                 S  s   g | ]
}|j ‘qS rW   )rO   rÌ   rW   rW   rX   rÏ   ¨  rÐ   )r^   Úconcatenate)rU   r
  r©   r¨   rQ   rW   rW   rX   Ú_concat_same_type¡  s    z!BaseMaskedArray._concat_same_typeznpt.NDArray[np.uint64])ÚencodingÚhash_keyÚ
categorizerR   c                C  s*   t | j|||d�}t| jjƒ||  ¡ < |S )N)r  r  r  )r@   rN   Úhashr`   ry   r*   )re   r  r  r  Zhashed_arrayrW   rW   rX   Ú_hash_pandas_object«  s
    
ÿz#BaseMaskedArray._hash_pandas_object)Ú
allow_fillÚ
fill_valuer©   zScalar | None)r  r  r©   rR   c          	      C  sp   t |ƒr| jn|}t| j||||d�}t| j|d||d�}|rdt|ƒrdt |¡dk}|||< ||A }|  ||¡S )N)r  r  r©   Tr€   )	r*   rL   r4   rN   rO   r+   r^   r½   rY   )	re   Zindexerr  r  r©   Zdata_fill_valuerV   rQ   Z	fill_maskrW   rW   rX   r4   ´  s     
ûÿzBaseMaskedArray.take)rP   rR   c                   sr   ddl m} t |¡}tˆ j|ƒ}ˆ jrR|jtkoFt	‡ fdd„|D ƒƒ}||ˆ j
< tjˆ jjtd�}|||dd�S )Nr   rD   c                 3  s   | ]}|ˆ j ju V  qd S rS   rÑ   )rÍ   r¢   ru   rW   rX   rè   á  s   z'BaseMaskedArray.isin.<locals>.<genexpr>rj   Fr‘   )rã   rE   r^   r½   r1   rN   rŸ   r`   r¾   r‚   rO   rë   rc   rZ   )re   rP   rE   Z
values_arrrV   Zvalues_have_NArQ   rW   ru   rX   r1   Ø  s    
ÿ
zBaseMaskedArray.isinc                 C  s    | j  ¡ }| j ¡ }|  ||¡S rS   )rN   r\   rO   rY   )re   r¨   rQ   rW   rW   rX   r\   ì  s    

zBaseMaskedArray.copyr‹   zLiteral['first', 'last', False])ÚkeeprR   c                 C  s   | j }| j}tj|||d�S )N)r  rQ   )rN   rO   ÚalgosÚ
duplicated)re   r  rP   rQ   rW   rW   rX   r  ñ  s    zBaseMaskedArray.duplicatedc                 C  s    t  | j| j¡\}}|  ||¡S )z‚
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )r  Zunique_with_maskrN   rO   rY   )re   ÚuniquesrQ   rW   rW   rX   Úuniqueù  s    zBaseMaskedArray.uniqueÚleftz$NumpyValueArrayLike | ExtensionArrayzLiteral['left', 'right']zNumpySorter | Noneznpt.NDArray[np.intp] | np.intp)r�   ÚsideÚsorterrR   c                 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]   r:   rÉ   r¾   rN   Úsearchsorted)re   r�   r  r  rW   rW   rX   r    s    ÿ

zBaseMaskedArray.searchsortedz!tuple[np.ndarray, ExtensionArray])Úuse_na_sentinelrR   c                 C  sò   | j }| j}t|d|d�\}}|j| jjks<J |j| jfƒ‚| ¡ }|sL|sVt|ƒ}nt|ƒd }tj|t	d�}|sÞ|rÞ| 
¡ }	|	dkr”t d¡}
n|d |	…  ¡ d }
|||
k  d7  < |
||dk< t ||
d¡}d||
< |  ||¡}||fS )NT)r  rQ   r�   rj   r   r€   )rN   rO   r0   r`   rÖ   r‚   r‡   r^   rë   rZ   r†   ZintpÚmaxÚinsertrY   )re   r  ÚarrrQ   Úcodesr  Zhas_naÚsizeZuniques_maskZna_indexZna_codeZ
uniques_earW   rW   rX   Ú	factorize  s(    
zBaseMaskedArray.factorizec                 C  s   | j S rS   r  ru   rW   rW   rX   Ú_values_for_argsort:  s    z#BaseMaskedArray._values_for_argsortrC   )ÚdropnarR   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rdd|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   )ÚIndexrC   r  ©r&  rQ   rj   Tr€   ÚcountF)ÚindexÚnamer\   )Úpandasr'  rC   Zpandas.arraysrâ   r  Zvalue_counts_arraylikerN   rO   r^   rë   r‡   ra   r\   r`   r×   )re   r&  r'  rC   râ   ÚkeysÚvalue_countsZ
na_counterZ
mask_indexrQ   r!  r*  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 )Nr(  rj   )	r3   rN   rO   r^   rë   rc   ra   rm   Zargsort)re   r&  rV   Zres_maskrW   rW   rX   Ú_modef  s    zBaseMaskedArray._modec                 C  sd   t | ƒt |ƒkrdS |j| jkr$dS t | j|j¡s8dS | j| j  }|j|j  }t||ddd�S )NFT)Z
strict_nanZdtype_equal)rm   r`   r^   Zarray_equalrO   rN   r(   )re   rô   r  ÚrightrW   rW   rX   Úequalso  s    zBaseMaskedArray.equalsznpt.NDArray[np.float64])ÚqsÚinterpolationrR   c                 C  s˜   t | j| jtj||d�}| jrz| jdkr,t‚|  ¡  	¡ rhtj
|jtd�}t| jƒrxtj|j| jjd�}qŠ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   r  r2  r3  é   rj   ræ   )r7   rN   rO   r^   rØ   rŸ   r~   rp   r*   r…   ro   rc   rZ   r"   r`   rë   rÖ   r¶   )re   r2  r3  ÚresZout_maskrW   rW   rX   Ú	_quantile  s"    ù


zBaseMaskedArray._quantile)ÚskipnaÚkeepdims)r+  r7  r8  c          
      K  s¸   |dv r"t | |ƒf d|i|¤Ž}n@| j}| j}t td|› �ƒ}| dd ¡}	||f|	||dœ|¤Ž}|r¢t|ƒr~| j|ddd�S | d	¡}tj	d	t
d
�}|  ||¡S t|ƒr°tjS |S d S )N>	   r  ÚmeanÚstdr‚   ÚminÚsumÚprodÚvarr…   r7  rØ   r©   )r©   r7  rQ   r   )r�   )r+  r©   Ú	mask_sizer�   rj   )rí   rN   rO   r.   Úpopr*   Ú_wrap_na_resultr®   r^   rë   rZ   r¶   rÃ   rÄ   )
re   r+  r7  r8  r±   rV   r¨   rQ   r  r©   rW   rW   rX   Ú_reduce«  s     
zBaseMaskedArray._reduce)r+  c                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   r+  rV   r7  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.|}nZ|dv sB| jjdkrN| jjj}n:tƒ pXt }|rbdnd	}|rnd
nd}	|||	|dœ| jj	 }t j
dg|d�}
| j|
|d�S )Nrj   ZFloat32rä   rÿ   )r9  Zmedianr>  r:  ZskewZkurt)r;  r  é   Zint32Zint64Zuint32Zuint64)r’   r£   Úur“   r�   ræ   )r^   ro   rZ   r`   ÚitemsizerÖ   r+  r   r   r”   r;   r¶   )re   r+  r©   r?  rQ   Z
float_dtypZnp_dtypeZis_windows_or_32bitZint_dtypZ	uint_dtypr�   rW   rW   rX   rA  Ð  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   rj   ©r7  r©   )r]   r^   r_   r¶   rë   rc   rZ   rC  )re   r+  rV   r7  Ú	min_countr©   rW   rW   rX   Ú _wrap_min_count_reduction_resultã  s    z0BaseMaskedArray._wrap_min_count_reduction_result©r7  rH  r©   zAxisInt | Nonec                K  s8   t  d|¡ tj| j| j|||d�}| jd||||d�S )NrW   rJ  r<  )r´   Zvalidate_sumr6   r<  rN   rO   rI  ©re   r7  rH  r©   r±   rV   rW   rW   rX   r<  ê  s    û
ÿzBaseMaskedArray.sumc                K  s8   t  d|¡ tj| j| j|||d�}| jd||||d�S )NrW   rJ  r=  )r´   Zvalidate_prodr6   r=  rN   rO   rI  rK  rW   rW   rX   r=  ÿ  s    û
ÿzBaseMaskedArray.prodrG  c                K  s4   t  d|¡ tj| j| j||d�}| jd|||d�S )NrW   rG  r9  )r´   Zvalidate_meanr6   r9  rN   rO   rC  ©re   r7  r©   r±   rV   rW   rW   rX   r9    s    üzBaseMaskedArray.meanr�   ©r7  r©   Úddofc                K  s:   t jd|dd� tj| j| j|||d�}| jd|||d�S )NrW   r>  ©ÚfnamerM  rG  )r´   Úvalidate_stat_ddof_funcr6   r>  rN   rO   rC  ©re   r7  r©   rN  r±   rV   rW   rW   rX   r>    s    ûzBaseMaskedArray.varc                K  s:   t jd|dd� tj| j| j|||d�}| jd|||d�S )NrW   r:  rO  rM  rG  )r´   rQ  r6   r:  rN   rO   rC  rR  rW   rW   rX   r:  +  s    ûzBaseMaskedArray.stdc                K  s4   t  d|¡ tj| j| j||d�}| jd|||d�S )NrW   rG  r;  )r´   Zvalidate_minr6   r;  rN   rO   rC  rL  rW   rW   rX   r;  8  s    üzBaseMaskedArray.minc                K  s4   t  d|¡ tj| j| j||d�}| jd|||d�S )NrW   rG  r  )r´   Zvalidate_maxr6   r  rN   rO   rC  rL  rW   rW   rX   r  B  s    üzBaseMaskedArray.maxc                 C  s   t |  ¡ ||d�S )N)Ú	na_action)r2   rÊ   )re   ZmapperrS  rW   rW   rX   ÚmapL  s    zBaseMaskedArray.mapc                K  sb   t  d|¡ | j ¡ }t || j| j¡ | ¡ }|r8|S |sRt	| ƒdksR| j ¡ sV|S | j
jS d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   N)r´   Zvalidate_anyrN   r\   r^   ÚputmaskrO   Ú_falsey_valuer‚   r‡   r`   ry   ©re   r7  r©   r±   rP   rV   rW   rW   rX   r‚   O  s    ?
zBaseMaskedArray.anyc                K  sf   t  d|¡ | j ¡ }t || j| j¡ |j|d�}|r<|S |rVt	| ƒdksV| j 
¡ sZ|S | jjS d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   N)r´   Zvalidate_allrN   r\   r^   rU  rO   Ú_truthy_valuer…   r‡   r‚   r`   ry   rW  rW   rW   rX   r…      s    ?
zBaseMaskedArray.allr   rI   )r|   r©   r\   rR   c             
   K  sÎ   | j jdkr4|r&| j ¡ }	| j ¡ }
ql| j}	| j}
n8| j jdv r\d}| j d¡}	| j ¡ }
ntd| j › �ƒ‚tj|	f|d|||||
dœ|¤Ž |s–| S | j jdkr²t	| ƒ 
|	|
¡S ddlm} | 
|	|
¡S d	S )
z2
        See NDFrame.interpolate.__doc__.
        r“   rÕ   TZf8z)interpolate is not implemented for dtype=r   )r|   r©   r*  rz   Úlimit_directionr{   rQ   rH   N)r`   r”   rN   r\   rO   rÉ   rp   r	   Zinterpolate_2d_inplacerm   rY   rã   rI   )re   r|   r©   r*  rz   rY  r{   r\   r±   r¨   rQ   rI   rW   rW   rX   Úinterpolateò  s@    

ÿÿø	÷zBaseMaskedArray.interpolate)r7  )r+  r7  rR   c                K  s<   | j }| j}tt|ƒ}|||fd|i|¤Ž\}}|  ||¡S )Nr7  )rN   rO   rí   r5   rY   )re   r+  r7  r±   r¨   rQ   r  rW   rW   rX   Ú_accumulate&  s
    
zBaseMaskedArray._accumulateznpt.NDArray[np.intp])ÚhowÚhas_dropped_narH  ÚngroupsÚidsc                K  sØ   ddl m} | |¡}||||d�}	| j}
|	jdkr>|
 ¡ }ntj|td�}|dkrn| 	d¡dv rnd	|d d …< |	j
| jf||||
|d
œ|¤Ž}|	jdkrº|	j 	|	jd¡}t ||df¡j}|	jdv rÈ|S |  ||¡S d S )Nr   )ÚWrappedCythonOp)r\  r”   r]  Z	aggregaterj   ZrankZ	na_option)ÚtopÚbottomF)rH  r^  Zcomp_idsrQ   Úresult_maskZohlcr�   )ZidxminZidxmax)Zpandas.core.groupby.opsr`  Zget_kind_from_howrO   r”   r\   r^   rë   rZ   ré   Z_cython_op_ndim_compatrN   r\  Z_cython_arityZtiler„   r¶   )re   r\  r]  rH  r^  r_  r±   r`  r”   r  rQ   rc  Z
res_valuesZarityrW   rW   rX   Ú_groupby_op4  s4    



ÿúù


zBaseMaskedArray._groupby_op)F)F)NNNT)r   )r   ).).).)T)NN)N)r   )r‹   )r  N)T)T)T)N)[rü   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   rX  rV  ÚclassmethodrY   rf   ri   r   r:   rq   rt   Úpropertyr`   r   rx   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É   Z__array_priority__rÝ   rñ   ró   rŸ   rõ   r  Z_logical_methodr  r¶   r*   rï   r	  r  r  r4   r1   r\   r  r  r  r$  r%  r.  r/  r1  r6  rB  rC  rA  rI  r<  r=  r9  r>  r:  r;  r  rT  r‚   r…   rZ  r[  rd  Ú__classcell__rW   rW   r�   rX   rK   l   s  
ÿú,ÿ!ÿ#ü]
.ÿM](/
ý	ú$ÿ üþ$(	-ÿ
ûûÿÿ

QR5ÿrK   zSequence[BaseMaskedArray]zlist[BaseMaskedArray])Úmasked_arraysrR   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 ]2}||d
d
…|f |d
d
…|f d�}	| |	¡ q�|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  s   g | ]}|j  d d¡‘qS ©r�   r€   )rN   r®   ©rÍ   r!  rW   rW   rX   rÏ   o  rÐ   z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>ÚF)Úorderr`   )r©   rà   c                 S  s   g | ]}|j  d d¡‘qS rm  )rO   r®   rn  rW   rW   rX   rÏ   z  rÐ   rj   r�   Nræ   )Úlistr`   r^   r  rl   r‡   rÖ   Z
empty_likerZ   r×   r¡   rc   rì   )
rl  r`   rP   Ztransposed_valuesZmasksZtransposed_masksZarr_typeZtransposed_arraysr£   Ztransposed_arrrW   rW   rX   Ú#transpose_homogeneous_masked_arraysd  s,    
ýý
ÿ$rr  )lÚ
__future__r   Útypingr   r   r   r   r   rÅ   Únumpyr^   Zpandas._libsr   r	   rÃ   Zpandas._libs.tslibsr
   Zpandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   Zpandas.compatr   r   Zpandas.errorsr   Zpandas.util._decoratorsr   Zpandas.util._exceptionsr   Zpandas.util._validatorsr   Zpandas.core.dtypes.baser    Zpandas.core.dtypes.commonr!   r"   r#   r$   r%   r&   Zpandas.core.dtypes.dtypesr'   Zpandas.core.dtypes.missingr(   r)   r*   r+   Zpandas.corer,   r  r-   r.   r/   Zpandas.core.algorithmsr0   r1   r2   r3   r4   Zpandas.core.array_algosr5   r6   Z pandas.core.array_algos.quantiler7   Zpandas.core.arrayliker8   Zpandas.core.arrays._utilsr9   Zpandas.core.arrays.baser:   Zpandas.core.constructionr;   rþ   r<   r=   Zpandas.core.indexersr>   Zpandas.core.opsr?   Zpandas.core.util.hashingr@   Úcollections.abcrA   rB   r,  rC   rã   rE   rF   rG   rI   Zpandas.compat.numpyrJ   r´   rK   rr  rW   rW   rW   rX   Ú<module>   s^   @             