U
    MZf+                     @  s  d dl mZ d dlmZmZ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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 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,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7 d dl8m9Z9m:Z:m;Z;m<Z< d dl=m>Z?m@Z@mZmAZAmBZB d dlCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZS d dlTmUZU erd dlVmWZW d dlNmXZX d dlmYZYmZZZ d dl[m\Z] edddZ^G dd deMeOZ_dS )     )annotations)TYPE_CHECKINGAnyIteratorLiteralSequenceTypeVaroverloadN)libmissing)get_unit_from_dtypeis_supported_unit)	ArrayLike	AstypeArgAxisIntDtypeObjNpDtypePositionalIndexerScalarScalarIndexerSequenceIndexerShapenptAbstractMethodError)doc)validate_fillna_kwargs)ExtensionDtype)is_boolis_bool_dtypeis_datetime64_dtypeis_dtype_equalis_float_dtypeis_integer_dtypeis_list_likeis_object_dtype	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)is_array_like)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker   nanopsops)factorize_arrayisintake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)ExtensionArray)ensure_wrapped_if_datetimelike)check_array_indexer)invalid_comparison)SeriesBooleanArray)NumpySorterNumpyValueArrayLike)functionBaseMaskedArrayTBaseMaskedArray)boundc                   @  s2  e Zd ZU dZded< ded< ded< eZeZdddd	d
dddZe	ddd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 dZdd!d"dd#dZeejdddd$d%d&Ze	dd'd(d	d)d*d+d,Zd-d. Zd
dd/d0Zd1dd2d3Zd4dd5d6Zed7dd8d9Zed4dd:d;Zddd$d<d=Zddd?dd@dAdBZddd$dCdDZddd$dEdFZeddd$dGdHZdd4dIdJdKZddd$dLdMZddd$dNdOZ ddd$dPdQZ!ddd$dRdSZ"dde#j$fdTd	dUddVdWdXZ%eej&dYdZ Z&edd\d	dd*d]d^Z'edd_d	d`d*dad^Z'eddbd	dcd*ddd^Z'ddbd	dcd*dfd^Z'dgZ(ddhddidjdkZ)dledm< dndodpdqdrZ*ddsdtZ+ed	ddudvZ,dwddxdydzZ-d{d| Z.e.Z/d}dd~dZ0dd Z1ddddZ2edd Z3ed4dddZ4e	dddd?ddddZ5ddd>ddd	dd?ddddZ6d}dddZ7ddd$ddZ8ddd$ddZ9eej:ddddddddZ:eej;dd	ddddZ;eej<ddddZ<dd	ddddZ=eej>d	dddZ>ddod dddZ?deddod	dddZ@dodddZAded>d>dd	d4ddddZBded>d>dd	d4ddddZCded>dd	ddddZDded>ddd	dd4dddZEded>ddd	dd4dddĄZFded>dd	ddddƄZGded>dd	ddddȄZHdedd	dddʄZIdedd	ddd̄ZJdeddod	d d͜ddτZKdS )rE   zf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   _internal_fill_valuez
np.ndarray_dataznpt.NDArray[np.bool_]_maskFboolNone)valuesmaskcopyreturnc                 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
ValueErrorrN   rH   rI   )selfrL   rM   rN    rY   =/tmp/pip-unpacked-wheel-nbcvw55c/pandas/core/arrays/masked.py__init__u   s    zBaseMaskedArray.__init__NrS   rN   ztype[BaseMaskedArrayT]rD   )clsrN   rO   c                C  s   | j |||d\}}| ||S )Nr\   )_coerce_to_array)r]   ZscalarsrS   rN   rL   rM   rY   rY   rZ   _from_sequence   s    zBaseMaskedArray._from_sequencer)   )rO   c                 C  s   t | d S Nr   rX   rY   rY   rZ   rS      s    zBaseMaskedArray.dtyper   r   )itemrO   c                 C  s   d S r`   rY   rX   rb   rY   rY   rZ   __getitem__   s    zBaseMaskedArray.__getitem__r   )rX   rb   rO   c                 C  s   d S r`   rY   rc   rY   rY   rZ   rd      s    r   zBaseMaskedArrayT | Anyc                 C  sF   t | |}| j| }t|r2|r(| jjS | j| S t| | j| |S r`   )r<   rI   r   rS   na_valuerH   type)rX   rb   ZnewmaskrY   rY   rZ   rd      s    


)rX   rO   c           	      C  s   t ||\}}| j}t|rPt|t| krHtdt| dt|  || }| r|d k	rtj|| jd}| j	
 j}|
 j}||||d t| |j|jS | 
 }|||< n| 
 }|S )Nz'Length of 'value' does not match. Got (z)  expected )ndim)limitrM   )r   rI   r*   lenrW   anyr   Zget_fill_funcrg   rH   rN   Trf   )	rX   valuemethodrh   rM   funcZnpvaluesZnew_maskZ
new_valuesrY   rY   rZ   fillna   s&    

zBaseMaskedArray.fillnarN   r   ztuple[np.ndarray, np.ndarray])rS   rN   rO   c                C  s   t | d S r`   r   )r]   rL   rS   rN   rY   rY   rZ   r^      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t| d| j  dS )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        bfzInvalid value 'z' for dtype N)rS   kindr
   r   
is_integerZis_floatrU   str)rX   rl   rs   rY   rY   rZ   _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 )NTFrS   )r<   r&   r,   rS   rI   rv   rH   r^   )rX   keyrl   rM   rY   rY   rZ   __setitem__   s    




zBaseMaskedArray.__setitem__r   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 )N   )	rg   _hasnarH   rS   re   ziprI   rangeri   )rX   valre   Zisna_irY   rY   rZ   __iter__   s    



zBaseMaskedArray.__iter__intc                 C  s
   t | jS r`   )ri   rH   ra   rY   rY   rZ   __len__
  s    zBaseMaskedArray.__len__r   c                 C  s   | j jS r`   )rH   rV   ra   rY   rY   rZ   rV     s    zBaseMaskedArray.shapec                 C  s   | j jS r`   )rH   rg   ra   rY   rY   rZ   rg     s    zBaseMaskedArray.ndimc                 C  s*   | j ||}| j||}t| ||S r`   )rH   swapaxesrI   rf   )rX   Zaxis1Zaxis2datarM   rY   rY   rZ   r     s    zBaseMaskedArray.swapaxesr   r   )rX   axisrO   c                 C  s2   t j| j||d}t j| j||d}t| ||S )Nr   )rQ   deleterH   rI   rf   )rX   locr   r   rM   rY   rY   rZ   r     s    zBaseMaskedArray.deletec                 O  s*   | j j||}| jj||}t| ||S r`   )rH   reshaperI   rf   rX   argskwargsr   rM   rY   rY   rZ   r     s    zBaseMaskedArray.reshapec                 O  s*   | j j||}| jj||}t| ||S r`   )rH   ravelrI   rf   r   rY   rY   rZ   r   $  s    zBaseMaskedArray.ravelc                 C  s   t | | jj| jjS r`   )rf   rH   rk   rI   ra   rY   rY   rZ   rk   *  s    zBaseMaskedArray.T)decimalsc                 O  s6   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   )nvZvalidate_roundrQ   roundrH   _maybe_mask_resultrI   rN   )rX   r   r   r   rL   rY   rY   rZ   r   .  s    zBaseMaskedArray.roundc                 C  s   t | | j | j S r`   rf   rH   rI   rN   ra   rY   rY   rZ   
__invert__O  s    zBaseMaskedArray.__invert__c                 C  s   t | | j | j S r`   r   ra   rY   rY   rZ   __neg__R  s    zBaseMaskedArray.__neg__c                 C  s   |   S r`   rp   ra   rY   rY   rZ   __pos__U  s    zBaseMaskedArray.__pos__c                 C  s   t | t| j| j S r`   )rf   absrH   rI   rN   ra   rY   rY   rZ   __abs__X  s    zBaseMaskedArray.__abs__znpt.DTypeLike | Noneobject)rS   rN   re   rO   c              	   C  s   |t jkrtj}|dkrt}| jrt|sLt|sL|tjkrLtd| dt	
   t	jdtd | j|}W 5 Q R X ||| j< n2t	
 $ t	jdtd | jj||d}W 5 Q R X |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categoryrp   )r
   
no_default
libmissingNAr   r{   r%   r'   rW   warningscatch_warningsfilterwarningsRuntimeWarningrH   astyperI   )rX   rS   rN   re   r   rY   rY   rZ   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|d S )Nrz   c                 S  s   g | ]}|  qS rY   )tolist.0xrY   rY   rZ   
<listcomp>  s     z*BaseMaskedArray.tolist.<locals>.<listcomp>rw   )rg   r{   rH   rS   r   r   rX   rS   rY   rY   rZ   r     s    
zBaseMaskedArray.tolist.znpt.DTypeLikec                 C  s   d S r`   rY   rX   rS   rN   rY   rY   rZ   r     s    zBaseMaskedArray.astyper   r:   c                 C  s   d S r`   rY   r   rY   rY   rZ   r     s    r   r   c                 C  s   d S r`   rY   r   rY   rY   rZ   r     s    Tc              	   C  s"  t |}t|| jr$|r |  S | S t|trt & tjdt	d | j
j|j|d}W 5 Q R X || j
krr| jn| j }| }|||ddS t|tr| }|j| ||dS t|rtj}nt|rtd}ntj}t|r| jrtdt|r| jrtd| j|||d	}|S )
Nr   r   rp   Fr\   NaTzcannot convert NA to integerz cannot convert float NaN to bool)rS   re   rN   )r(   r!   rS   rN   rP   r)   r   r   r   r   rH   r   numpy_dtyperI   Zconstruct_array_typer   r_   r"   rQ   nanr    Z
datetime64r
   r   r#   r{   rW   r   r   )rX   rS   rN   r   rM   r]   Zeaclsre   rY   rY   rZ   r     s4    


i  zNpDtype | None)rS   rO   c                 C  s   | j |dS )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rw   )r   r   rY   rY   rZ   	__array__  s    zBaseMaskedArray.__array__ztuple[type, ...]_HANDLED_TYPESznp.ufuncru   )ufuncrm   c           	        sT  | dd}|| D ]}t|| jtf st  S qtj| ||f||}|tk	rV|S d|krttj| ||f||S |dkrtj	| ||f||}|tk	r|S t
jt| td g }|D ]0}t|trވ |jO  ||j q|| q fddt||||}|jdkr(tfdd	|D S |dkrH| j rD| jS |S |S d S )
NoutrY   reducerw   c                   s   ddl m}m}m} t| jr0  }|| |S t| jrL  }|| |S t| jr  }| jt	j
krv| t	j} || |S t	j|  < | S )Nr   )r@   FloatingArrayIntegerArray)pandas.core.arraysr@   r   r   r   rS   rN   r#   r"   rQ   Zfloat16r   Zfloat32r   )r   r@   r   r   mrM   rY   rZ   reconstruct,  s    






z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructrz   c                 3  s   | ]} |V  qd S r`   rY   r   )r   rY   rZ   	<genexpr>I  s     z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)getrP   r   rE   NotImplementedr2   Z!maybe_dispatch_ufunc_to_dunder_opr0   Zdispatch_ufunc_with_outZdispatch_reduction_ufuncrQ   zerosri   rJ   rI   appendrH   getattrZnouttuplerj   	_na_value)	rX   r   rm   inputsr   r   r   resultZinputs2rY   )rM   r   rZ   __array_ufunc__  sj    
      


zBaseMaskedArray.__array_ufunc__c                 C  s   ddl }|j| j| j|dS )z6
        Convert myself into a pyarrow Array.
        r   N)rM   rf   )ZpyarrowarrayrH   rI   )rX   rf   parY   rY   rZ   __arrow_array__R  s    zBaseMaskedArray.__arrow_array__c                 C  s
   | j  S r`   )rI   rj   ra   rY   rY   rZ   r{   Z  s    zBaseMaskedArray._hasnaznpt.NDArray[np.bool_] | None)rM   rO   c                 C  sZ   |d krL| j  }|tjkr&|dB }qVt|rVt|t|krV|t|B }n
| j |B }|S )NT)rI   rN   r   r   r$   ri   r-   )rX   rM   otherrY   rY   rZ   _propagate_maskc  s    



zBaseMaskedArray._propagate_maskc              	   C  s  |j }d }t|dst|rt|t| krtj|dd}|dkrZddlm} ||}n>|dkrzddlm	} ||}n|d	krdd
lm
} ||}t|tr|j|j }}n.t|rt|tst|}|jdkrtdt|t| f}t|}	t|}|dkr$t|tjr$t|}| ||}
|tjkrt| j}| jjdkr|dkrptd| d|dkrd}nd}| |}n$d|kr| jjdkr| tj!}n@| jjdkr|dkr|}	tj"dd |	| j|}W 5 Q R X |dkr`t#| jdk| j @ d|
}
|d k	r@t#|dk| @ d|
}
n|tjk	rt#|dkd|
}
nh|dkr|d k	rt#|dk| @ d|
}
n|tjk	rt#|dkd|
}
t#| jdk| j @ d|
}
| $||
S )NrS   Tskipnaintegerr   r   )Zfloatingzmixed-integer-floatr   )booleanr?   rz   (can only perform ops with 1-d structures>   powrpowrq   >   	rfloordivr   r   floordivrtruedivtruedivz
operator 'z!' not implemented for bool dtypes>   rmodmodZint8rJ   r   rr   )r   u)r   r   r   allr   Fr   )%__name__hasattrr$   ri   r
   Zinfer_dtyper   r   r_   r   r@   rP   rE   rH   rI   r:   rQ   asarrayrg   NotImplementedErrorr2   Zmaybe_prepare_scalar_for_opZget_array_opr;   rT   rJ   r   r   r   Z	ones_likerS   rs   r   Zfloat64errstatewherer   )rX   r   opZop_nameZomaskZinferred_dtyper   r   r@   Zpd_oprM   r   rS   rY   rY   rZ   _arith_methods  sz    













zBaseMaskedArray._arith_methodr@   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krtj| jjdd}tj| jjdd}n~t p tdd	t tdd	t tjdd
$ t| jd|j d}||}W 5 Q R X |tkr
t| j||}W 5 Q R X | ||}|||ddS )Nr   r?   rz   r   zLengths must match to comparerJ   rw   r   Zelementwiser   __Frp   )r   r@   rP   rE   rH   rI   r$   rQ   r   rg   r   ri   rW   r   r   r   rV   onesr   r   r   FutureWarningDeprecationWarningr   r   r   r   r=   r   )rX   r   r   r@   rM   r   rm   rY   rY   rZ   _cmp_method  s.    





zBaseMaskedArray._cmp_methodc           	      C  s  t |tr*|\}}| ||| ||fS t|jrNddlm} |||ddS t|jrrddlm} |||ddS t |jt	jr|jj
dkrtt|jrddlm} t ||s|j||jd}|jd	||< |S t|j rd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   Frp   r?   r   )TimedeltaArrayrw   r   r   N)rP   r   r   r"   rS   r   r   r   r@   rQ   rs   r   r   r   Z_simple_newrf   r#   r   r   )	rX   r   rM   divr   r   r@   r   r   rY   rY   rZ   r     s6    







z"BaseMaskedArray._maybe_mask_resultc                 C  s
   | j  S r`   )rI   rN   ra   rY   rY   rZ   r-   7  s    zBaseMaskedArray.isnac                 C  s   | j jS r`   rS   re   ra   rY   rY   rZ   r   :  s    zBaseMaskedArray._na_valuec                 C  s   | j j| jj S r`   )rH   nbytesrI   ra   rY   rY   rZ   r   >  s    zBaseMaskedArray.nbyteszSequence[BaseMaskedArrayT])r]   	to_concatr   rO   c                 C  s:   t jdd |D |d}t jdd |D |d}| ||S )Nc                 S  s   g | ]
}|j qS rY   rH   r   rY   rY   rZ   r   H  s     z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r   c                 S  s   g | ]
}|j qS rY   )rI   r   rY   rY   rZ   r   I  s     )rQ   Zconcatenate)r]   r   r   r   rM   rY   rY   rZ   _concat_same_typeB  s    z!BaseMaskedArray._concat_same_type)
allow_fill
fill_valuer   zScalar | None)rX   r   r   r   rO   c          	      C  sv   t |r| jn|}t| j||||d}t| j|d||d}|rdt|rdt|dk}|||< ||A }t| ||ddS )N)r   r   r   TFrp   )	r-   rG   r5   rH   rI   r.   rQ   r   rf   )	rX   Zindexerr   r   r   Zdata_fill_valuer   rM   Z	fill_maskrY   rY   rZ   r5   L  s(    
    zBaseMaskedArray.takec                   sr   ddl m} t|}t j|} jrRt|joFt	 fdd|D }|| j
< tj jjtd}|||ddS )Nr   r?   c                 3  s   | ]}| j jkV  qd S r`   r   )r   r~   ra   rY   rZ   r   y  s    z'BaseMaskedArray.isin.<locals>.<genexpr>rw   Frp   )r   r@   rQ   r   r4   rH   r{   r%   rS   rj   rI   r   rV   rJ   )rX   rL   r@   Z
values_arrr   Zvalues_have_NArM   rY   ra   rZ   r4   p  s    

zBaseMaskedArray.isinc                 C  s0   | j | j }}| }| }t| ||ddS )NFrp   )rH   rI   rN   rf   )rX   r   rM   rY   rY   rZ   rN     s    zBaseMaskedArray.copyc                 C  s&   t | j| j\}}t| ||ddS )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        Frp   )algosZunique_with_maskrH   rI   rf   )rX   uniquesrM   rY   rY   rZ   unique  s    zBaseMaskedArray.uniqueleftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]rA   znpt.NDArray[np.intp] | np.intp)rl   sidesorterrO   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{   rW   rP   r:   r   r   rH   searchsorted)rX   rl   r   r   rY   rY   rZ   r     s    

zBaseMaskedArray.searchsortedz!tuple[np.ndarray, ExtensionArray])use_na_sentinelrO   c                 C  s   | j }| j}t|d|d\}}|j| jjks<t|j| jf| }|sL|sVt|}nt|d }tj	|t
d}|s|r| }	|	dkrtd}
n|d |	  d }
|||
k  d7  < |
||dk< t||
d}d||
< t| ||}||fS )NT)r   rM   rz   rw   r   r   )rH   rI   r3   rS   r   AssertionErrorrj   ri   rQ   r   rJ   ZargmaxZintpmaxinsertrf   )rX   r   ZarrrM   codesr   Zhas_nasizeZuniques_maskZna_indexZna_codeZ
uniques_earY   rY   rZ   	factorize  s(    
zBaseMaskedArray.factorizec                 C  s   | j S r`   r   ra   rY   rY   rZ   _values_for_argsort  s    z#BaseMaskedArray._values_for_argsortr>   )dropnarO   c                 C  s   ddl m}m} ddlm} tj| jd| jd\}}|rf|||ddd}|j	
| j|_	|
d	}|S tjt|d
 dd}||dd< | j |d< ||| jdt|| jj}	|	
| j}	tjt|dd}
|||
}|||	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   )Indexr>   r   T)r  rM   countF)indexnamerN   ZInt64rz   Zint64rw   Nr   rJ   )pandasr  r>   Zpandas.arraysr   r   Zvalue_counts_arraylikerH   rI   r  r   rS   rQ   emptyri   sumr   re   r   )rX   r  r  r>   r   keysvalue_countsrescountsr  rM   Zcounts_arrayrY   rY   rZ   r    s(      


zBaseMaskedArray.value_countsc                 C  sb   t | t |krdS |j| jkr$dS t| j|js8dS | j| j  }|j|j  }t||ddS )NFT)Zdtype_equal)rf   rS   rQ   Zarray_equalrI   rH   r+   )rX   r   r   rightrY   rY   rZ   equals  s    zBaseMaskedArray.equalsznpt.NDArray[np.float64])qsinterpolationrO   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}qt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.
        )rM   r   r  r     rw   r   )r8   rH   rI   rQ   r   r{   rg   r   r-   r   r   rV   rJ   r#   rS   r   r   r   )rX   r  r  r  Zout_maskrY   rY   rZ   	_quantile  s"    


zBaseMaskedArray._quantiler   )r  r   c                K  sh   |dkr t | |f d|i|S | j}| j}t td| }||fd||d|}t|rdtjS |S )N>	   varminprodr	  r   r   meanstdrj   r   r   r   )r   r   rM   )r   rH   rI   r1   rQ   isnanr   r   )rX   r  r   r   r   rM   r   r   rY   rY   rZ   _reduce;  s    
zBaseMaskedArray._reduce)r  c                 K  sF   t |tjrB|d }|r(| jj|d}n| jj|d}| ||S |S )Nr   r   )rP   rQ   rR   rI   r   rj   r   )rX   r  r   r   r   r   rM   rY   rY   rZ   _wrap_reduction_resultK  s    z&BaseMaskedArray._wrap_reduction_resultr   	min_countr   zAxisInt | Nonec                K  s`   t d| d|kr.|d d k	r$t|d tj| j| j|||d}| jd|f||d|S )NrY   r   r  r	  r   r   )	r   Zvalidate_sumr   popr7   r	  rH   rI   r  rX   r   r  r   r   r   rY   rY   rZ   r	  W  s*    
  zBaseMaskedArray.sumc                K  s>   t d| tj| j| j|||d}| jd|f||d|S )NrY   r  r  r  )r   Zvalidate_prodr7   r  rH   rI   r  r   rY   rY   rZ   r  s  s"      zBaseMaskedArray.prodr  c                K  s<   t d| tj| j| j||d}| jd|f||d|S )NrY   r  r  )r   Zvalidate_meanr7   r  rH   rI   r  )rX   r   r   r   r   rY   rY   rZ   r    s       zBaseMaskedArray.meanrz   r   r   ddofc                K  sB   t jd|dd tj| j| j|||d}| jd|f||d|S )NrY   r  fnamer!  r  )r   validate_stat_ddof_funcr7   r  rH   rI   r  rX   r   r   r"  r   r   rY   rY   rZ   r    s"      zBaseMaskedArray.varc                K  sB   t jd|dd tj| j| j|||d}| jd|f||d|S )NrY   r  r#  r!  r  )r   r%  r7   r  rH   rI   r  r&  rY   rY   rZ   r    s"      zBaseMaskedArray.stdc                K  s"   t d| tj| j| j||dS NrY   r  )r   Zvalidate_minr7   r  rH   rI   rX   r   r   r   rY   rY   rZ   r    s    zBaseMaskedArray.minc                K  s"   t d| tj| j| j||dS r'  )r   Zvalidate_maxr7   r   rH   rI   r(  rY   rY   rZ   r     s    zBaseMaskedArray.maxc                K  sn   | dd td| | j }t|| j| j |	 }|rD|S |s^t
| dks^| j	 sb|S | jjS dS )a1  
        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.
        **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>
        r   NrY   r   )r  r   Zvalidate_anyrH   rN   rQ   putmaskrI   _falsey_valuerj   ri   rS   re   rX   r   r   rL   r   rY   rY   rZ   rj     s    >
zBaseMaskedArray.anyc                K  sn   | dd td| | j }t|| j| j |	 }|rD|S |r^t
| dks^| j sb|S | jjS dS )a$  
        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.
        **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
        r   NrY   r   )r  r   Zvalidate_allrH   rN   rQ   r)  rI   _truthy_valuer   ri   rj   rS   re   r+  rY   rY   rZ   r     s    >
zBaseMaskedArray.all)r  r   rO   c                K  sB   | j }| j}tt|}|||fd|i|\}}t| ||ddS )Nr   Frp   )rH   rI   r   r6   rf   )rX   r  r   r   r   rM   r   rY   rY   rZ   _accumulatef  s
    
zBaseMaskedArray._accumulate)F)NNN)r   )r   ).).).)T)N)N)r   )r   N)T)T)Lr   
__module____qualname____doc____annotations__r   r,  r*  r[   classmethodr_   propertyrS   r	   rd   r   r:   ro   r^   rv   ry   r   r   rV   rg   r   r   r   r   rk   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   r5   r4   rN   r   r   r   r  r  r  r  r  r  r	  r  r  r  r  r  r   rj   r   r-  rY   rY   rY   rZ   rE   d   s   
       !\
.M
i)0
 $   &.,    		QS)`
__future__r   typingr   r   r   r   r   r   r	   r   ZnumpyrQ   Zpandas._libsr
   r   r   Zpandas._libs.tslibsr   r   Zpandas._typingr   r   r   r   r   r   r   r   r   r   r   Zpandas.errorsr   Zpandas.util._decoratorsr   Zpandas.util._validatorsr   Zpandas.core.dtypes.baser   Zpandas.core.dtypes.commonr   r   r    r!   r"   r#   r$   r%   r&   r'   r(   Zpandas.core.dtypes.dtypesr)   Zpandas.core.dtypes.inferencer*   Zpandas.core.dtypes.missingr+   r,   r-   r.   Zpandas.corer/   r   r0   r1   r2   Zpandas.core.algorithmsr3   r4   r5   Zpandas.core.array_algosr6   r7   Z pandas.core.array_algos.quantiler8   Zpandas.core.arrayliker9   r   r:   Zpandas.core.constructionr;   Zpandas.core.indexersr<   Zpandas.core.opsr=   r  r>   r@   rA   rB   Zpandas.compat.numpyrC   r   rD   rE   rY   rY   rY   rZ   <module>   s<   $	44