U
    cQ                     @  s  d dl mZ d dl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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$ d dl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0 d dl1m2Z2 d dl3m4Z4 d dl5m6Z6m7Z7m8Z8m9Z9 d dl:m;Z<m=Z=mZm>Z>m?Z? d dl@mAZAmBZBmCZC d dlDmEZE d dlFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ erd dlRmSZS d dlJmTZT d dlmUZUmVZV d dlWmXZY edddZZG dd deIeKZ[dS )     )annotations)TYPE_CHECKINGAnyLiteralSequenceTypeVaroverloadN)libmissing)
	ArrayLike	AstypeArgDtypeObjNpDtypePositionalIndexerScalarScalarIndexerSequenceIndexerShapenptAbstractMethodError)doc)validate_fillna_kwargs)astype_nansafe)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_reductions)quantile_with_mask)OpsMixin)ExtensionArray)ensure_wrapped_if_datetimelike)check_array_indexer)invalid_comparison)SeriesBooleanArray)NumpySorterNumpyValueArrayLike)functionBaseMaskedArrayTBaseMaskedArray)boundc                   @  s  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d1d2 Zd3dd4d5Zed6dd7d8Zed3dd9d:Zddd$d;d<Zddd3dd>d?d@Zddd$dAdBZddd$dCdDZeddd$dEdFZdd3dGdHdIZddd$dJdKZddd$dLdMZ ddd$dNdOZ!ddd$dPdQZ"dde#j$fdRd	dSddTdUdVZ%eddXd	dd*dYdZZ&edd[d	d\d*d]dZZ&edd^d	d_d*d`dZZ&dd^d	d_d*dbdZZ&dcZ'dddddedfdgZ(dhedi< djdkdldmdnZ)ddodpZ*ed	ddqdrZ+dsddtdudvZ,dwdx Z-e-Z.dyddzd{Z/d|d} Z0ddd~dZ1edd Z2ed3dddZ3e	dddd3ddddZ4ddd=ddd	dd3ddddZ5dydddZ6ddd$ddZ7ddd$ddZ8eej9ddddddddZ9eej:e#j$e#j$fddddddZ:eej;ddddZ;dd	ddddZ<eej=d	dddZ=ddkd dddZ>daddkd	dddZ?dkdddZ@dad=d=dddddZAdad=d=dddddZBdad=dddddZCdad=dddddZDdadd	dddZEdadd	dddÄZFdS )rA   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
ValueErrorrJ   rD   rE   )selfrH   rI   rJ    rU   =/tmp/pip-unpacked-wheel-g7fro6k3/pandas/core/arrays/masked.py__init__m   s    zBaseMaskedArray.__init__NrO   rJ   ztype[BaseMaskedArrayT]r@   )clsrJ   rK   c                C  s   | j |||d\}}| ||S )NrX   )_coerce_to_array)rY   ZscalarsrO   rJ   rH   rI   rU   rU   rV   _from_sequence   s    zBaseMaskedArray._from_sequencer&   )rK   c                 C  s   t | d S Nr   rT   rU   rU   rV   rO      s    zBaseMaskedArray.dtyper   r   )itemrK   c                 C  s   d S r\   rU   rT   r^   rU   rU   rV   __getitem__   s    zBaseMaskedArray.__getitem__r   )rT   r^   rK   c                 C  s   d S r\   rU   r_   rU   rU   rV   r`      s    r   zBaseMaskedArrayT | Anyc                 C  sF   t | |}| j| }t|r2|r(| jjS | j| S t| | j| |S r\   )r8   rE   r   rO   na_valuerD   type)rT   r^   ZnewmaskrU   rU   rV   r`      s    


)rT   rK   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)limitrI   )r   rE   r'   lenrS   anyr
   Zget_fill_funcrc   rD   rJ   Trb   )	rT   valuemethodrd   rI   funcZnpvaluesZnew_maskZ
new_valuesrU   rU   rV   fillna   s&    

zBaseMaskedArray.fillnarJ   r   ztuple[np.ndarray, np.ndarray])rO   rJ   rK   c                C  s   t | d S r\   r   )rY   rH   rO   rJ   rU   rU   rV   rZ      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)rO   kindr	   r   
is_integerZis_floatrQ   str)rT   rh   ro   rU   rU   rV   _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rO   )r8   r#   r)   rO   rE   rr   rD   rZ   )rT   keyrh   rI   rU   rU   rV   __setitem__   s    




zBaseMaskedArray.__setitem__c                 c  s`   | j dkr@tt| D ]&}| j| r0| jjV  q| j| V  qntt| D ]}| | V  qLd S )N   )rc   rangere   rE   rO   ra   rD   )rT   irU   rU   rV   __iter__   s    

zBaseMaskedArray.__iter__intc                 C  s
   t | jS r\   )re   rD   r]   rU   rU   rV   __len__   s    zBaseMaskedArray.__len__r   c                 C  s   | j jS r\   )rD   rR   r]   rU   rU   rV   rR      s    zBaseMaskedArray.shapec                 C  s   | j jS r\   )rD   rc   r]   rU   rU   rV   rc     s    zBaseMaskedArray.ndimc                 C  s*   | j ||}| j||}t| ||S r\   )rD   swapaxesrE   rb   )rT   Zaxis1Zaxis2datarI   rU   rU   rV   r|     s    zBaseMaskedArray.swapaxesr   )rT   axisrK   c                 C  s2   t j| j||d}t j| j||d}t| ||S )Nr~   )rM   deleterD   rE   rb   )rT   locr~   r}   rI   rU   rU   rV   r     s    zBaseMaskedArray.deletec                 O  s*   | j j||}| jj||}t| ||S r\   )rD   reshaperE   rb   rT   argskwargsr}   rI   rU   rU   rV   r     s    zBaseMaskedArray.reshapec                 O  s*   | j j||}| jj||}t| ||S r\   )rD   ravelrE   rb   r   rU   rU   rV   r     s    zBaseMaskedArray.ravelc                 C  s   t | | jj| jjS r\   )rb   rD   rg   rE   r]   rU   rU   rV   rg     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_roundrM   roundrD   _maybe_mask_resultrE   rJ   )rT   r   r   r   rH   rU   rU   rV   r   !  s    zBaseMaskedArray.roundc                 C  s   t | | j | j S r\   rb   rD   rE   rJ   r]   rU   rU   rV   
__invert__B  s    zBaseMaskedArray.__invert__c                 C  s   t | | j | j S r\   r   r]   rU   rU   rV   __neg__E  s    zBaseMaskedArray.__neg__c                 C  s   |   S r\   rl   r]   rU   rU   rV   __pos__H  s    zBaseMaskedArray.__pos__c                 C  s   t | t| j| j S r\   )rb   absrD   rE   rJ   r]   rU   rU   rV   __abs__K  s    zBaseMaskedArray.__abs__znpt.DTypeLike | Noneobject)rO   rJ   ra   rK   c                 C  sx   |t jkrtj}|dkrt}| jrdt|sLt|sL|tjkrLtd| d| j	
|}||| j< n| j	j
||d}|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.rl   )r	   
no_default
libmissingNAr   _hasnar"   r$   rS   rD   astyperE   )rT   rO   rJ   ra   r}   rU   rU   rV   to_numpyP  s$    B

zBaseMaskedArray.to_numpy.znpt.DTypeLikec                 C  s   d S r\   rU   rT   rO   rJ   rU   rU   rV   r     s    zBaseMaskedArray.astyper   r6   c                 C  s   d S r\   rU   r   rU   rU   rV   r     s    r   r   c                 C  s   d S r\   rU   r   rU   rU   rV   r     s    Tc                 C  s  t |}t|| jr$|r |  S | S t|trp| jj|j|d}|| jkrP| 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rtd| j|||d}| jjdkrt||ddS |S )	Nrl   FrX   NaTzcannot convert NA to integerz cannot convert float NaN to bool)rO   ra   rJ   rn   )r%   r   rO   rJ   rL   r&   rD   r   numpy_dtyperE   Zconstruct_array_typer   r[   r   rM   nanr   Z
datetime64r	   r   r    r   rS   r   r   ro   r   )rT   rO   rJ   r}   rI   rY   Zeaclsra   rU   rU   rV   r     s4    

i  zNpDtype | None)rO   rK   c                 C  s   | j |dS )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rs   )r   )rT   rO   rU   rU   rV   	__array__  s    zBaseMaskedArray.__array__ztuple[type, ...]_HANDLED_TYPESznp.ufuncrq   )ufuncri   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outrU   reducers   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   rO   rJ   r    r   rM   Zfloat16r   Zfloat32r   )xr<   r   r   mrI   rU   rV   reconstruct  s    






z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructrv   c                 3  s   | ]} |V  qd S r\   rU   .0r   )r   rU   rV   	<genexpr>2  s     z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)getrL   r   rA   NotImplementedr/   Z!maybe_dispatch_ufunc_to_dunder_opr-   Zdispatch_ufunc_with_outZdispatch_reduction_ufuncrM   zerosre   rF   rE   appendrD   getattrZnouttuplerf   	_na_value)	rT   r   ri   inputsr   r   r   resultZinputs2rU   )rI   r   rV   __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)rI   rb   )ZpyarrowarrayrD   rE   )rT   rb   parU   rU   rV   __arrow_array__;  s    zBaseMaskedArray.__arrow_array__c                 C  s
   | j  S r\   )rE   rf   r]   rU   rU   rV   r   C  s    zBaseMaskedArray._hasnaznpt.NDArray[np.bool_] | None)rI   rK   c                 C  s4   |d kr&| j  }|tjkr0|dB }n
| j |B }|S )NT)rE   rJ   r   r   )rT   rI   otherrU   rU   rV   _propagate_maskL  s    



zBaseMaskedArray._propagate_maskc           	   	   C  s>  |j }d }t|tr$|j|j }}n.t|rRt|ts@t|}|j	dkrRt
dt|t| f}t|}t|}|dkrt|tjrt|}| ||}|tjkr t| j}| jjdkr|dkrt
d| dn|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rt| jdk| j @ d|}|d k	rt|dk| @ d|}n|tjk	r2t|dkd|}nh|dkr2|d k	rt|dk| @ d|}n|tjk	rt|dkd|}t| jdk| j @ d|}| ||S )Nrv   (can only perform ops with 1-d structures>   rpowpowrm   >   truedivr   	rfloordivr   rtruedivfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodZint8rF   r   rn   )rx   u)r   r   ignoreallr   Fr   r   )__name__rL   rA   rD   rE   r!   r6   rM   asarrayrc   NotImplementedErrorr/   Zmaybe_prepare_scalar_for_opre   Zget_array_opr7   rP   rF   r   r   r   Z	ones_likerO   ro   r   float64errstatewherer   )	rT   r   opZop_nameZomaskZpd_oprI   r   rO   rU   rU   rV   _arith_methodX  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}nnt ` tdd	t tjdd
$ t| jd|j d}||}W 5 Q R X |tkrt| j||}W 5 Q R X | ||}|||ddS )Nr   r;   rv   r   zLengths must match to comparerF   rs   r   Zelementwiser   __Frl   )r   r<   rL   rA   rD   rE   r!   rM   r   rc   r   re   rS   r   r   r   rR   oneswarningscatch_warningsfilterwarningsFutureWarningr   r   r   r   r9   r   )rT   r   r   r<   rI   r   ri   rU   rU   rV   _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 |jdkrddlm	} t ||s|
|}|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   Frl   r;   ztimedelta64[ns])TimedeltaArrayr   r   N)rL   r   r   r   rO   r   r   r   r<   r   Z_simple_newrb   r    r   rM   r   )	rT   r   rI   divr   r   r<   r   r   rU   rU   rV   r     s,    









z"BaseMaskedArray._maybe_mask_resultc                 C  s
   | j  S r\   )rE   rJ   r]   rU   rU   rV   r*     s    zBaseMaskedArray.isnac                 C  s   | j jS r\   rO   ra   r]   rU   rU   rV   r     s    zBaseMaskedArray._na_valuec                 C  s   | j j| jj S r\   )rD   nbytesrE   r]   rU   rU   rV   r   	  s    zBaseMaskedArray.nbyteszSequence[BaseMaskedArrayT])rY   	to_concatr~   rK   c                 C  s:   t jdd |D |d}t jdd |D |d}| ||S )Nc                 S  s   g | ]
}|j qS rU   rD   r   rU   rU   rV   
<listcomp>  s     z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r   c                 S  s   g | ]
}|j qS rU   )rE   r   rU   rU   rV   r     s     )rM   Zconcatenate)rY   r   r~   r}   rI   rU   rU   rV   _concat_same_type  s    z!BaseMaskedArray._concat_same_type)
allow_fill
fill_valuer~   zScalar | None)rT   r   r   r~   rK   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~   TFrl   )	r*   rC   r2   rD   rE   r+   rM   r   rb   )	rT   Zindexerr   r   r~   Zdata_fill_valuer   rI   Z	fill_maskrU   rU   rV   r2     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   valr]   rU   rV   r   E  s    z'BaseMaskedArray.isin.<locals>.<genexpr>rs   Frl   )r   r<   rM   r   r1   rD   r   r"   rO   rf   rE   r   rR   rF   )rT   rH   r<   Z
values_arrr   Zvalues_have_NArI   rU   r]   rV   r1   ;  s    

zBaseMaskedArray.isinc                 C  s0   | j | j }}| }| }t| ||ddS )NFrl   )rD   rE   rJ   rb   )rT   r}   rI   rU   rU   rV   rJ   P  s    zBaseMaskedArray.copyc                 C  s&   t | j| j\}}t| ||ddS )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        Frl   )algosZunique_with_maskrD   rE   rb   )rT   uniquesrI   rU   rU   rV   uniqueV  s    zBaseMaskedArray.uniqueleftz$NumpyValueArrayLike | ExtensionArrayzLiteral[('left', 'right')]r=   znpt.NDArray[np.intp] | np.intp)rh   sidesorterrK   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   rS   rL   r6   r   r   rD   searchsorted)rT   rh   r   r   rU   rU   rV   r   a  s    

zBaseMaskedArray.searchsortedzint | lib.NoDefaultzbool | lib.NoDefaultz!tuple[np.ndarray, ExtensionArray])na_sentineluse_na_sentinelrK   c                 C  s  t ||}| j}| j}|d kr$dn|}t|||d\}}|j| jjksXt|j| jf| }	|d k	sl|	svt	|}
nt	|d }
t
j|
td}|d kr|	r| }|dkrt
d}n|d |  d }|||k  d7  < |||dk< t
||d}d||< t| ||}||fS )Nr   )r   rI   rv   rs   r   T)r   Zresolve_na_sentinelrD   rE   r0   rO   r   AssertionErrorrf   re   rM   r   rF   ZargmaxZintpmaxinsertrb   )rT   r   r   Zresolved_na_sentinelZarrrI   Zna_sentinel_argcodesr   Zhas_nasizeZuniques_maskZna_indexZna_codeZ
uniques_earU   rU   rV   	factorizer  s,    
zBaseMaskedArray.factorizec                 C  s   | j S r\   r   r]   rU   rU   rV   _values_for_argsort  s    z#BaseMaskedArray._values_for_argsortr:   )dropnarK   c                 C  s  ddl m}m} ddlm} |rbtj| jd| jd\}}|||d}|j	
| j|_	|
d}|S | j| j  }|| }	|	j	}
|r|	j}nDtjt|	d d	d
}|	|dd< | j |d< |
t|
| jj}
|

| j}
tjt|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   rI   )indexZInt64rv   Zint64rs   Nr   rF   )pandasr   r:   Zpandas.arraysr   r   Zvalue_counts_arraylikerD   rE   r   r   rO   value_countsZ_valuesrM   emptyre   sumr   ra   r   )rT   r   r   r:   r   keyscountsresr}   r   r   rI   Zcounts_arrayrU   rU   rV   r     s2      


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)rb   rO   rM   Zarray_equalrE   rD   r(   )rT   r   r   rightrU   rU   rV   equals  s    zBaseMaskedArray.equalsznpt.NDArray[np.float64])qsinterpolationrK   c                 C  s   t | j| jtj||d}| jr|| jdkr.tq|  	 rjtj
|jtd}t| jrzt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.
        )rI   r   r   r      rs   r   )r4   rD   rE   rM   r   r   rc   r   r*   r   r   rR   rF   r    rO   r   r   r   )rT   r   r   r   Zout_maskrU   rU   rV   	_quantile  s"    


zBaseMaskedArray._quantile)skipna)namer  c                K  s   |dkr t | |f d|i|S | j}| j}|dkrXt t|}|||fd|i|}|S | jrn| jdtjd}t td| }||fd||d|}t	|rt
jS |S )	N>   r   prodminr   rf   r   r  >   meanr   )ra   r   r   )r~   r  rI   )r   rD   rE   r3   r   r   rM   r   r.   isnanr   r   )rT   r  r  r   r}   rI   r   r   rU   rU   rV   _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   )rL   rM   rN   rE   r   rf   r   )rT   r  r   r  r   r~   rI   rU   rU   rV   _wrap_reduction_result-  s    z&BaseMaskedArray._wrap_reduction_resultr  	min_countr~   z
int | Noner   c                K  s`   t d| d|kr.|d d k	r$t|d tj| j| j|||d}| jd|f||d|S )NrU   r   r  r   r  r~   )	r   Zvalidate_sumr   popr3   r   rD   rE   r
  rT   r  r  r~   r   r   rU   rU   rV   r   9  s*    
  zBaseMaskedArray.sumc                K  s>   t d| tj| j| j|||d}| jd|f||d|S )NrU   r  r  r  )r   Zvalidate_prodr3   r  rD   rE   r
  r  rU   rU   rV   r  N  s"      zBaseMaskedArray.prodr  c                K  s"   t d| tj| j| j||dS NrU   r  )r   Zvalidate_minr3   r  rD   rE   rT   r  r~   r   rU   rU   rV   r  [  s    zBaseMaskedArray.minc                K  s"   t d| tj| j| j||dS r  )r   Zvalidate_maxr3   r   rD   rE   r  rU   rU   rV   r   d  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~   NrU   r   )r  r   Zvalidate_anyrD   rJ   rM   putmaskrE   _falsey_valuerf   re   rO   ra   rT   r  r   rH   r   rU   rU   rV   rf   m  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~   NrU   r   )r  r   Zvalidate_allrD   rJ   rM   r  rE   _truthy_valuer   re   rf   rO   ra   r  rU   rU   rV   r     s    >
zBaseMaskedArray.all)F)NNN)r   )r   ).).).)T)N)N)r   )r   N)T)Gr   
__module____qualname____doc____annotations__r   r  r  rW   classmethodr[   propertyrO   r   r`   r   r6   rk   rZ   rr   ru   ry   r{   rR   rc   r|   r   r   r   rg   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   r2   r1   rJ   r   r   r   r   r   r   r  r	  r
  r   r  r  r   rf   r   rU   rU   rU   rV   rA   \   s   
       !X/M
T(,
 $  )7,		Q)\
__future__r   typingr   r   r   r   r   r   r   ZnumpyrM   Zpandas._libsr	   r
   r   Zpandas._typingr   r   r   r   r   r   r   r   r   r   Zpandas.errorsr   Zpandas.util._decoratorsr   Zpandas.util._validatorsr   Zpandas.core.dtypes.astyper   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   r-   r.   r/   Zpandas.core.algorithmsr0   r1   r2   Zpandas.core.array_algosr3   Z pandas.core.array_algos.quantiler4   Zpandas.core.arrayliker5   r   r6   Zpandas.core.constructionr7   Zpandas.core.indexersr8   Zpandas.core.opsr9   r   r:   r<   r=   r>   Zpandas.compat.numpyr?   r   r@   rA   rU   rU   rU   rV   <module>   s<    04