o
    ôT·jÝ  ã                   @  sJ  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(„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                      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)rK   Ú__new__rN   rP   )ÚclsrQ   rR   Úresult© rX   ú\/home/dinkstrade/pdmp-scanner/venv/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Ú
ValueErrorr[   rN   rP   )ÚselfrQ   rR   r[   rX   rX   rY   Ú__init__„   s   ÿ
zBaseMaskedArray.__init__N©ra   r[   c                C  s   | j |||d�\}}| ||ƒS )Nrh   )Ú_coerce_to_array)rV   Úscalarsra   r[   rQ   rR   rX   rX   rY   Ú_from_sequence—   s   
zBaseMaskedArray._from_sequencerd   r   ra   r    c                 C  s\   t j||jd�}| | j¡ t j|td�}| ||ƒ}t|| ƒr$||jkr,t	d|› d�ƒ‚|S )N©ra   z5Default 'empty' implementation is invalid for dtype='ú')
r_   ÚemptyÚtypeÚfillrL   Úonesr\   r^   ra   ÚNotImplementedError)rV   rd   ra   rQ   rR   rW   rX   rX   rY   Ú_emptyœ   s   

ÿzBaseMaskedArray._emptyÚboxedúCallable[[Any], str | None]c                 C  s   t S rT   )Ústr)rf   rt   rX   rX   rY   Ú
_formatter©   ó   zBaseMaskedArray._formatterr'   c                 C  ó   t | ƒ‚rT   r   ©rf   rX   rX   rY   ra   ­   ó   zBaseMaskedArray.dtypeÚitemr   r   c                 C  ó   d S rT   rX   ©rf   r|   rX   rX   rY   Ú__getitem__±   rx   zBaseMaskedArray.__getitem__r   c                 C  r}   rT   rX   r~   rX   rX   rY   r   µ   rx   r   ú
Self | Anyc                 C  sD   t | |ƒ}| j| }t|ƒr|r| jjS | j| S |  | j| |¡S rT   )r>   rP   r!   ra   Úna_valuerN   rZ   )rf   r|   ÚnewmaskrX   rX   rY   r   ¹   s   


T)ÚlimitÚ
limit_arear[   Ú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ƒ   rR   éÿÿÿÿé   ÚinsideÚoutside)rP   Úanyr	   Úget_fill_funcr‰   rN   ÚTr[   ÚallÚargmaxÚlenrZ   )rf   r…   rƒ   r„   r[   rR   ÚfuncÚnpvaluesÚnew_maskÚneg_maskÚfirstÚlastÚ
new_valuesrX   rX   rY   Ú_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   rP   r	   Úcheck_value_sizer”   r�   r�   r‰   rN   r‘   r[   rZ   )
rf   Úvaluer…   rƒ   r[   rR   r•   r–   r—   r›   rX   rX   rY   Úfillnañ   s.   
üÿzBaseMaskedArray.fillna©r[   r   útuple[np.ndarray, np.ndarray]c                C  ry   rT   r   )rV   rQ   ra   r[   rX   rX   rY   ri     s   z BaseMaskedArray._coerce_to_arrayc                 C  sz   | 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|›d| j › d�ƒ‚)zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        ÚbÚfzInvalid value 'z' for dtype 'rm   )ra   Úkindr   r!   Ú
is_integerÚis_floatrc   )rf   rž   r¤   rX   rX   rY   Ú_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 )NTFrl   )r>   r$   r)   ra   rP   r§   rN   ri   )rf   Úkeyrž   rR   rX   rX   rY   Ú__setitem__4  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*   ra   r�   rN   r¤   r   r¦   r\   r_   ÚisnanrP   r�   ÚsuperÚ__contains__)rf   r¨   ©Ú	__class__rX   rY   r¬   E  s   zBaseMaskedArray.__contains__rA   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‰   Ú_hasnarN   ra   r�   ÚziprP   Úranger”   )rf   Úvalr�   Úisna_ÚirX   rX   rY   Ú__iter__M  s   €

ÿüÿzBaseMaskedArray.__iter__Úintc                 C  s
   t | jƒS rT   )r”   rN   rz   rX   rX   rY   Ú__len__]  ó   
zBaseMaskedArray.__len__c                 C  ó   | j jS rT   )rN   rd   rz   rX   rX   rY   rd   `  r{   zBaseMaskedArray.shapec                 C  r¹   rT   )rN   r‰   rz   rX   rX   rY   r‰   d  r{   zBaseMaskedArray.ndimc                 C  s(   | j  ||¡}| j ||¡}|  ||¡S rT   )rN   ÚswapaxesrP   rZ   )rf   Úaxis1Úaxis2ÚdatarR   rX   rX   rY   rº   h  s   zBaseMaskedArray.swapaxesr   Úaxisr   c                 C  s0   t j| j||d�}t j| j||d�}|  ||¡S ©N©r¾   )r_   ÚdeleterN   rP   rZ   )rf   Úlocr¾   r½   rR   rX   rX   rY   rÁ   m  ó   zBaseMaskedArray.deletec                 O  s0   | j j|i |¤Ž}| jj|i |¤Ž}|  ||¡S rT   )rN   ÚreshaperP   rZ   ©rf   ÚargsÚkwargsr½   rR   rX   rX   rY   rÄ   r  rÃ   zBaseMaskedArray.reshapec                 O  s2   | j j|i |¤Ž}| jj|i |¤Ž}t| ƒ||ƒS rT   )rN   ÚravelrP   ro   rÅ   rX   rX   rY   rÈ   w  s   zBaseMaskedArray.ravelc                 C  s   |   | jj| jj¡S rT   )rZ   rN   r‘   rP   rz   rX   rX   rY   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É   )
ra   r¤   ÚnvÚvalidate_roundr_   ÚroundrN   Ú_maybe_mask_resultrP   r[   )rf   rÉ   rÆ   rÇ   rQ   rX   rX   rY   rÌ   �  s
   zBaseMaskedArray.roundc                 C  s   |   | j | j ¡ ¡S rT   ©rZ   rN   rP   r[   rz   rX   rX   rY   Ú
__invert__¤  ó   zBaseMaskedArray.__invert__c                 C  s   |   | j | j ¡ ¡S rT   rÎ   rz   rX   rX   rY   Ú__neg__§  rÐ   zBaseMaskedArray.__neg__c                 C  s   |   ¡ S rT   r    rz   rX   rX   rY   Ú__pos__ª  s   zBaseMaskedArray.__pos__c                 C  s   |   t| jƒ| j ¡ ¡S rT   )rZ   ÚabsrN   rP   r[   rz   rX   rX   rY   Ú__abs__­  s   zBaseMaskedArray.__abs__c                 C  s   t j| td�S )Nrl   )r_   ÚasarrayÚobjectrz   rX   rX   rY   Ú_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¯   r9   rÖ   r%   Ú
libmissingÚNAre   ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrN   ÚastyperP   )rf   ra   r[   r�   Úhasnar½   rX   rX   rY   Ú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 rX   )Útolist©Ú.0ÚxrX   rX   rY   Ú
<listcomp>  s    z*BaseMaskedArray.tolist.<locals>.<listcomp>©ra   r�   )r‰   r¯   rN   ra   rä   rÜ   rÝ   rå   )rf   ra   rX   rX   rY   rå     s   
zBaseMaskedArray.tolist.únpt.DTypeLikec                 C  r}   rT   rX   ©rf   ra   r[   rX   rX   rY   râ     rx   zBaseMaskedArray.astyper:   c                 C  r}   rT   rX   rì   rX   rX   rY   râ     rx   r   r   c                 C  r}   rT   rX   rì   rX   rX   rY   râ   !  rx   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    Frh   r£   ÚMÚNaTÚiuzcannot convert NA to integerr¢   z cannot convert float NaN to bool)ra   r�   r[   )r&   ra   r[   r^   r'   rÞ   rß   rà   rá   rN   râ   Únumpy_dtyperP   Úconstruct_array_typer    rk   r¤   r_   ÚnanÚ
datetime64r   Ú
no_defaultr¯   re   rä   )rf   ra   r[   r½   rR   rV   Úeaclsr�   rX   rX   rY   râ   %  s6   


ý


iè  úNpDtype | Noneúbool | Nonec                 C  sL   |du r| 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
        Frh   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ì   rX   rX   rY   Ú	__array__U  s   øzBaseMaskedArray.__array__ztuple[type, ...]Ú_HANDLED_TYPESÚufuncúnp.ufuncrv   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ÚoutrX   Úreducerl   rè   rM   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   )rE   rI   ÚIntegerArrayr¢   rï   r£   )Úpandas.core.arraysrE   rI   r  ra   r¤   r[   r_   Úfloat16râ   Úfloat32rò   )rè   rE   rI   r  Úm©rR   rX   rY   Úreconstruct™  s   



z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructrŒ   c                 3  s   � | ]}ˆ |ƒV  qd S rT   rX   ræ   )r  rX   rY   Ú	<genexpr>¶  s   € z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)rè   rM   )Úgetr^   rü   rK   ÚNotImplementedr-   Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr_   Úzerosr”   r\   rP   ÚappendrN   ÚgetattrÚnoutÚtupler�   Ú	_na_value)	rf   rý   r…   ÚinputsrÇ   rÿ   rè   rW   Úinputs2rX   )rR   r  rY   Ú__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)rR   ro   )Úpyarrowr;   rN   rP   )rf   ro   ÚparX   rX   rY   Ú__arrow_array__¿  s   zBaseMaskedArray.__arrow_array__c                 C  ó
   | j  ¡ S rT   )rP   r�   rz   rX   rX   rY   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)rP   r[   rÜ   rÝ   r#   r”   r*   )rf   rR   ÚotherrX   rX   rY   Ú_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 )Nra   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^   rK   rN   rP   r:   r_   rÕ   r‰   rr   r/   Úmaybe_prepare_scalar_for_opÚget_array_opr<   rb   r\   r  rÜ   rÝ   Ú	ones_likera   r¤   râ   Úfloat64ÚerrstateÚwhererÍ   )	rf   r  ÚopÚop_nameÚomaskÚpd_oprR   rW   ra   rX   rX   rY   Ú_arith_methodà  sn   ÿþ







ÿ€ÿ
€

zBaseMaskedArray._arith_methodrE   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   rD   rŒ   r  zLengths must match to comparer\   rl   rÙ   ÚelementwiseÚ__Fr    )r  rE   r^   rK   rN   rP   r#   r_   rÕ   r‰   rr   r”   re   rÜ   rÝ   r  rd   rq   rÞ   rß   rà   rú   ÚDeprecationWarningr  r)  r
  r?   r  )rf   r  r2  rE   rR   rW   r…   rX   rX   rY   Ú_cmp_method?  s0   




€ôzBaseMaskedArray._cmp_methodrW   ú*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   rH   Fr    r¢   rD   r  )ÚTimedeltaArrayrî   rl   rï   ©r  )r^   r  rÍ   ra   r¤   r  rI   rE   r   Úis_np_dtyper
   r<  ro   rZ   r  r_   rò   )	rf   rW   rR   Údivr&  rI   rE   r<  r  rX   rX   rY   rÍ   g  s,   
	

þ

z"BaseMaskedArray._maybe_mask_resultc                 C  r  rT   )rP   r[   rz   rX   rX   rY   r*   –  r¸   zBaseMaskedArray.isnac                 C  r¹   rT   rê   rz   rX   rX   rY   r  ™  r{   zBaseMaskedArray._na_valuec                 C  s   | j j| jj S rT   )rN   ÚnbytesrP   rz   rX   rX   rY   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 rX   ©rN   ræ   rX   rX   rY   ré   §  ó    z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>rÀ   c                 S  rC  rX   )rP   ræ   rX   rX   rY   ré   ¨  rE  )r_   Úconcatenate)rV   rA  r¾   r½   rR   rX   rX   rY   Ú_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)rH  rI  rJ  )r@   rN   Úhashra   r�   r*   )rf   rH  rI  rJ  Úhashed_arrayrX   rX   rY   Ú_hash_pandas_object«  s
   
ÿz#BaseMaskedArray._hash_pandas_object)Ú
allow_fillÚ
fill_valuer¾   rO  rP  úScalar | Nonec          	      C  sp   t |ƒr| jn|}t| j||||d�}t| j|d||d�}|r2t|ƒr2t |¡dk}|||< ||A }|  ||¡S )N)rP  rO  r¾   Tr‹   )	r*   rL   r4   rN   rP   r+   r_   rÕ   rZ   )	rf   ÚindexerrO  rP  r¾   Údata_fill_valuerW   rR   Ú	fill_maskrX   rX   rY   r4   ´  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   rD   c                 3  s   � | ]	}|ˆ j ju V  qd S rT   rê   )rç   r²   rz   rX   rY   r  á  s   € 
ÿz'BaseMaskedArray.isin.<locals>.<genexpr>rl   Fr    )r  rE   r_   rÕ   r1   rN   r¯   ra   rÖ   r�   rP   r  rd   r\   )rf   rQ   rE   Ú
values_arrrW   Úvalues_have_NArR   rX   rz   rY   r1   Ø  s   
ÿ
zBaseMaskedArray.isinc                 C  s    | j  ¡ }| j ¡ }|  ||¡S rT   )rN   r[   rP   rZ   )rf   r½   rR   rX   rX   rY   r[   ì  s   

zBaseMaskedArray.copyr™   ÚkeepúLiteral['first', 'last', False]c                 C  s   | j }| j}tj|||d�S )N)rW  rR   )rN   rP   ÚalgosÚ
duplicated)rf   rW  rQ   rR   rX   rX   rY   rZ  ñ  s   zBaseMaskedArray.duplicatedc                 C  s    t  | j| j¡\}}|  ||¡S )z‚
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rY  Úunique_with_maskrN   rP   rZ   )rf   ÚuniquesrR   rX   rX   rY   Ú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`  rb  )r¯   re   r^   r:   râ   rÖ   rN   Úsearchsorted)rf   rž   r`  rb  rX   rX   rY   re    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)rf  rR   rŒ   rl   r   r‹   )rN   rP   r0   ra   rð   r�   r”   r_   r  r\   r“   ÚintpÚmaxÚinsertrZ   )rf   rf  ÚarrrR   Úcodesr\  Úhas_naÚsizeÚuniques_maskÚna_indexÚna_codeÚ
uniques_earX   rX   rY   Ú	factorize  s(   
zBaseMaskedArray.factorizec                 C  s   | j S rT   rD  rz   rX   rX   rY   Ú_values_for_argsort:  s   z#BaseMaskedArray._values_for_argsortÚdropnarC   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   )ÚIndexrC   r=  ©ru  rR   rl   Tr‹   ÚcountF)ÚindexÚnamer[   )Úpandasrv  rC   Úpandas.arraysr  rY  Úvalue_counts_arraylikerN   rP   r_   r  r”   rb   r[   ra   rñ   )rf   ru  rv  rC   r  ÚkeysÚvalue_countsÚ
na_counterÚ
mask_indexrR   rk  ry  rX   rX   rY   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 )Nrw  rl   )	r3   rN   rP   r_   r  rd   rb   ro   Úargsort)rf   ru  rW   Úres_maskrX   rX   rY   Ú_modef  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)ro   ra   r_   Úarray_equalrP   rN   r(   )rf   r  r^  ÚrightrX   rX   rY   Úequalso  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.
        )rR   rP  rŠ  rŒ  é   rl   r  )r7   rN   rP   r_   rò   r¯   r‰   rr   r*   r’   rq   rd   r\   r"   ra   r  rð   rÍ   )rf   rŠ  rŒ  ÚresÚout_maskrX   rX   rY   Ú	_quantile  s$   ù


€zBaseMaskedArray._quantile)ÚskipnaÚkeepdimsrz  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�   ri  ÚminÚstdÚsumÚvarÚmeanÚprodr‘  rò   r¾   )r¾   r‘  rR   r   )rŒ   )rz  r¾   Ú	mask_sizerŒ   rl   rX   )r  rN   rP   r.   Úpopr*   Ú_wrap_na_resultrÄ   r_   r  r\   rÍ   rÜ   rÝ   )
rf   rz  r‘  r’  rÇ   rW   r½   rR   r2  r¾   rX   rX   rY   Ú_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`   rP   r’   r�   rÍ   )rf   rz  rW   r‘  r¾   rR   rX   rX   rY   Ú_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 )Nrl   ÚFloat32r  r/  )r—  Úmedianr–  r”  ÚskewÚkurt)r“  ri  é   Úint32Úint64Úuint32Úuint64)r¢   r´   Úur£   rŒ   r  )r_   rq   r\   ra   Úitemsizerð   rz  r   r   r¤   r;   rÍ   )rf   rz  r¾   r™  rR   Ú
float_dtypÚnp_dtypeÚis_windows_or_32bitÚint_dtypÚ	uint_dtyprž   rX   rX   rY   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   rl   ©r‘  r¾   )r^   r_   r`   rÍ   r  rd   r\   r�  )rf   rz  rW   r‘  Ú	min_countr¾   rX   rX   rY   Ú _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 )NrX   r±  r•  )rÊ   Úvalidate_sumr6   r•  rN   rP   r°  ©rf   r‘  r¯  r¾   rÇ   rW   rX   rX   rY   r•  ê  ó   û
ÿzBaseMaskedArray.sumc                K  r³  )NrX   r±  r˜  )rÊ   Úvalidate_prodr6   r˜  rN   rP   r°  rµ  rX   rX   rY   r˜  ÿ  r¶  zBaseMaskedArray.prodr®  c                K  ó4   t  d|¡ tj| j| j||d�}| jd|||d�S )NrX   r®  r—  )rÊ   Úvalidate_meanr6   r—  rN   rP   r�  ©rf   r‘  r¾   rÇ   rW   rX   rX   rY   r—    ó   üzBaseMaskedArray.meanrŒ   ©r‘  r¾   Úddofr½  c                K  ó:   t jd|dd� tj| j| j|||d�}| jd|||d�S )NrX   r–  ©Úfnamer¼  r®  )rÊ   Úvalidate_stat_ddof_funcr6   r–  rN   rP   r�  ©rf   r‘  r¾   r½  rÇ   rW   rX   rX   rY   r–    ó   ûzBaseMaskedArray.varc                K  r¾  )NrX   r”  r¿  r¼  r®  )rÊ   rÁ  r6   r”  rN   rP   r�  rÂ  rX   rX   rY   r”  +  rÃ  zBaseMaskedArray.stdc                K  r¸  )NrX   r®  r“  )rÊ   Úvalidate_minr6   r“  rN   rP   r�  rº  rX   rX   rY   r“  8  r»  zBaseMaskedArray.minc                K  r¸  )NrX   r®  ri  )rÊ   Úvalidate_maxr6   ri  rN   rP   r�  rº  rX   rX   rY   ri  B  r»  zBaseMaskedArray.maxc                 C  s   t |  ¡ ||d�S )N)Ú	na_action)r2   rä   )rf   ÚmapperrÆ  rX   rX   rY   ÚmapL  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>
        rX   r   )rÊ   Úvalidate_anyrN   r[   r_   ÚputmaskrP   Ú_falsey_valuer�   r”   ra   r�   ©rf   r‘  r¾   rÇ   rQ   rW   rX   rX   rY   r�   O  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
        rX   rÀ   r   )rÊ   Úvalidate_allrN   r[   r_   rÊ  rP   Ú_truthy_valuer’   r”   r�   ra   r�   rÌ  rX   rX   rY   r’      s   ?
zBaseMaskedArray.allr   rI   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¾   ry  rƒ   Úlimit_directionr„   rR   rH   )ra   r¤   rN   r[   rP   râ   rr   r	   Úinterpolate_2d_inplacero   rZ   r  rI   )rf   r…   r¾   ry  rƒ   rÐ  r„   r[   rÇ   r½   rR   rI   rX   rX   rY   Úinterpolateò  s@   

ÿÿø	÷zBaseMaskedArray.interpolate)r‘  c                K  s<   | j }| j}tt|ƒ}|||fd|i|¤Ž\}}|  ||¡S )Nr‘  )rN   rP   r  r5   rZ   )rf   rz  r‘  rÇ   r½   rR   r2  rX   rX   rY   Ú_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Õ  Ú	aggregaterl   ÚrankÚ	na_option)ÚtopÚbottomF)r¯  rÖ  Úcomp_idsrR   Úresult_maskÚohlcrŒ   )ÚidxminÚidxmax)Úpandas.core.groupby.opsrÙ  Úget_kind_from_howrP   r¤   r[   r_   r  r\   r	  Ú_cython_op_ndim_compatrN   rÔ  Ú_cython_arityÚtiler‘   rÍ   )rf   rÔ  rÕ  r¯  rÖ  r×  rÇ   rÙ  r¤   r2  rR   rà  Ú
res_valuesÚarityrX   rX   rY   Ú_groupby_op4  s4   

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


zBaseMaskedArray._groupby_op)rQ   rM   rR   rO   rS   r   )F)rQ   rM   rR   rO   r[   r\   rS   r]   )r[   r\   rS   r   )rd   r   ra   r    )rt   r\   rS   ru   )rS   r'   )r|   r   rS   r   )r|   r   rS   r   )r|   r   rS   r€   )
r…   r   rƒ   r†   r„   r‡   r[   r\   rS   r   )NNNT)rƒ   r†   r[   r\   rS   r   )ra   r   r[   r\   rS   r¡   )rS   r]   )rS   r\   )rS   rA   )rS   r¶   )rS   r   )rS   r   )r   )r¾   r   rS   r   )rÉ   r¶   )rS   rM   )ra   rØ   r[   r\   r�   rÖ   rS   rM   ).)ra   rë   r[   r\   rS   rM   )ra   r    r[   r\   rS   r:   )ra   r   r[   r\   rS   r   )T)NN)ra   rö   r[   r÷   rS   rM   )rý   rþ   r…   rv   rT   )rR   r  rS   rO   )rS   rE   )rW   r;  rR   rM   )rA  rB  r¾   r   rS   r   )rH  rv   rI  rv   rJ  r\   rS   rK  )rO  r\   rP  rQ  r¾   r   rS   r   )rQ   r   rS   rE   )r™   )rW  rX  rS   rO   )r^  N)rž   r_  r`  ra  rb  rc  rS   rd  )rf  r\   rS   rg  )ru  r\   rS   rC   )ru  r\   rS   r   )rŠ  r‹  rŒ  rv   rS   rK   )rz  rv   r‘  r\   r’  r\   )rz  rv   )r‘  r\   r¯  r¶   r¾   r²  )r‘  r\   r¾   r²  )r‘  r\   r¾   r²  r½  r¶   )r…   r   r¾   r¶   r[   r\   rS   rI   )rz  rv   r‘  r\   rS   rK   )
rÔ  rv   rÕ  r\   r¯  r¶   rÖ  r¶   r×  rØ  )[r)  Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   rÎ  rË  ÚclassmethodrZ   rg   rk   r   r:   rs   rw   Úpropertyra   r   r   rœ   rŸ   ri   r§   r©   r¬   rµ   r·   rd   r‰   rº   rÁ   rÄ   rÈ   r‘   rÌ   rÏ   rÑ   rÒ   rÔ   r×   r   rô   rä   rå   râ   Ú__array_priority__rû   r  r  r¯   r  r6  Ú_logical_methodr:  rÍ   r*   r  r@  rG  rN  r4   r1   r[   rZ  r]  re  rs  rt  r  r„  r‰  r�  rœ  r�  r›  r°  r•  r˜  r—  r–  r”  r“  ri  rÈ  r�   r’   rÒ  rÓ  rë  Ú__classcell__rX   rX   r­   rY   rK   l   s  
 ÿú,ÿ!ÿ#ü]
.ÿM](/
ý	ú$ÿüþ$(	-ÿ
ûûÿÿ

QR5ÿrK   Úmasked_arraysúSequence[BaseMaskedArray]rS   ú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‹   )rN   rÄ   ©rç   rk  rX   rX   rY   ré   o  ó    z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>ÚF)Úorderra   )r¾   rÿ   c                 S  rø  rù  )rP   rÄ   rú  rX   rX   rY   ré   z  rû  rl   rŒ   Nr  )Úlistra   r_   rF  rn   r”   rð   Ú
empty_liker\   rñ   r±   rd   r  )
rõ  ra   rQ   Útransposed_valuesÚmasksÚtransposed_masksÚarr_typeÚtransposed_arraysr´   Útransposed_arrrX   rX   rY   Ú#transpose_homogeneous_masked_arraysd  s,   
ýý
ÿ$r  )rõ  rö  rS   r÷  )lÚ
__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._exceptionsr   Ú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,   rY  r-   r.   r/   Úpandas.core.algorithmsr0   r1   r2   r3   r4   Úpandas.core.array_algosr5   r6   Ú pandas.core.array_algos.quantiler7   Úpandas.core.arrayliker8   Úpandas.core.arrays._utilsr9   Úpandas.core.arrays.baser:   Úpandas.core.constructionr;   r+  r<   r=   Úpandas.core.indexersr>   Úpandas.core.opsr?   Úpandas.core.util.hashingr@   Úcollections.abcrA   rB   r{  rC   r  rE   rF   rG   rI   Úpandas.compat.numpyrJ   rÊ   rK   r  rX   rX   rX   rY   Ú<module>   s`    @             