o
    5cb                     @  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                   @  sx  e Zd ZU dZded< ded< ded< eZeZ	ddddZe	ddddddZ
edddZedddZedd"dZdd%dZeej	ddd&d'Ze	dd(dd,d-Zd.d/ Zdd0d1Zd2d3 Zdd5d6Zedd8d9Zedd:d;Zdd<d=Zddd@dAZddBdCZddDdEZeddFdGZdddIdJZddKdLZddMdNZ ddOdPZ!ddQdRZ"dde#j$fddVdWZ%edddZd[Z&eddd^d[Z&edddad[Z&dddcd[Z&ddZ'dddfdgZ(dhedi< ddndoZ)ddpdqZ*eddrdsZ+ddudvZ,dwdx Z-e-Z.ddzd{Z/d|d} Z0dd~dZ1edd Z2edddZ3e		>ddddZ4ddd>ddddZ5dddZ6dddZ7dddZ8eej9		ddddZ9eej:e#j$e#j$fdddZ:eej;dddZ;ddddZ<eej=dddZ=dddZ>dbddddZ?dddZ@dbd>d>ddddZAdbd>d>ddddZBdbd>ddddZCdbd>ddddÄZDdbddddńZEdbddddǄZFdS )rA   zf
    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_]_maskFvaluesmaskcopyboolreturn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
ValueErrorrJ   rE   rG   )selfrH   rI   rJ    rW   O/var/www/html/gps/gps/lib/python3.10/site-packages/pandas/core/arrays/masked.py__init__m   s   
zBaseMaskedArray.__init__NrQ   rJ   clstype[BaseMaskedArrayT]r@   c                C  s   | j |||d\}}| ||S )NrZ   )_coerce_to_array)r[   scalarsrQ   rJ   rH   rI   rW   rW   rX   _from_sequence   s   
zBaseMaskedArray._from_sequencer&   c                 C     t | Nr   rV   rW   rW   rX   rQ         zBaseMaskedArray.dtypeitemr   r   c                 C     d S ra   rW   rV   rd   rW   rW   rX   __getitem__      zBaseMaskedArray.__getitem__rV   r   c                 C  re   ra   rW   rf   rW   rW   rX   rg      rh   r   BaseMaskedArrayT | Anyc                 C  sF   t | |}| j| }t|r|r| jjS | j| S t| | j| |S ra   )r8   rG   r   rQ   na_valuerE   type)rV   rd   newmaskrW   rW   rX   rg      s   


c           	      C  s   t ||\}}| j}t|r(t|t| kr$tdt| dt|  || }| r]|d urStj|| jd}| j	
 j}|
 j}||||d t| |j|jS | 
 }|||< |S | 
 }|S )Nz'Length of 'value' does not match. Got (z)  expected )ndim)limitrI   )r   rG   r'   lenrU   anyr
   get_fill_funcrm   rE   rJ   Trk   )	rV   valuemethodrn   rI   funcnpvaluesnew_mask
new_valuesrW   rW   rX   fillna   s,   
zBaseMaskedArray.fillnarJ   rQ   r   tuple[np.ndarray, np.ndarray]c                C  r`   ra   r   )r[   rH   rQ   rJ   rW   rW   rX   r]      s   z BaseMaskedArray._coerce_to_arrayc                 C  s|   | j j}|dkrt|r|S n!|dkr!t|st|r |S nt|s/t|r1| r1|S tdt| d| j  )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        bfzInvalid value 'z' for dtype )rQ   kindr	   r   
is_integeris_floatrS   str)rV   rs   r~   rW   rW   rX   _validate_setitem_value   s   
z'BaseMaskedArray._validate_setitem_valuec                 C  sz   t | |}t|r't|| jrd| j|< d S | |}|| j|< d| j|< d S | j|| jd\}}|| j|< || j|< d S )NTFrQ   )r8   r#   r)   rQ   rG   r   rE   r]   )rV   keyrs   rI   rW   rW   rX   __setitem__   s   





zBaseMaskedArray.__setitem__c                 c  sd    | j dkr"tt| D ]}| j| r| jjV  q| j| V  qd S tt| D ]}| | V  q(d S )N   )rm   rangero   rG   rQ   rj   rE   )rV   irW   rW   rX   __iter__   s   

zBaseMaskedArray.__iter__intc                 C  s
   t | jS ra   )ro   rE   rb   rW   rW   rX   __len__      
zBaseMaskedArray.__len__r   c                 C     | j jS ra   )rE   rT   rb   rW   rW   rX   rT      rc   zBaseMaskedArray.shapec                 C  r   ra   )rE   rm   rb   rW   rW   rX   rm     rc   zBaseMaskedArray.ndimc                 C  s*   | j ||}| j||}t| ||S ra   )rE   swapaxesrG   rk   )rV   axis1axis2datarI   rW   rW   rX   r     s   zBaseMaskedArray.swapaxesr   axisc                 C  s2   t j| j||d}t j| j||d}t| ||S )Nr   )rO   deleterE   rG   rk   )rV   locr   r   rI   rW   rW   rX   r        zBaseMaskedArray.deletec                 O  2   | j j|i |}| jj|i |}t| ||S ra   )rE   reshaperG   rk   rV   argskwargsr   rI   rW   rW   rX   r     r   zBaseMaskedArray.reshapec                 O  r   ra   )rE   ravelrG   rk   r   rW   rW   rX   r     s   zBaseMaskedArray.ravelc                 C  s   t | | jj| jjS ra   )rk   rE   rr   rG   rb   rW   rW   rX   rr     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   )nvvalidate_roundrO   roundrE   _maybe_mask_resultrG   rJ   )rV   r   r   r   rH   rW   rW   rX   r   !  s   zBaseMaskedArray.roundc                 C  s   t | | j | j S ra   rk   rE   rG   rJ   rb   rW   rW   rX   
__invert__B     zBaseMaskedArray.__invert__c                 C  s   t | | j | j S ra   r   rb   rW   rW   rX   __neg__E  r   zBaseMaskedArray.__neg__c                 C  s   |   S ra   rz   rb   rW   rW   rX   __pos__H  s   zBaseMaskedArray.__pos__c                 C  s   t | t| j| j S ra   )rk   absrE   rG   rJ   rb   rW   rW   rX   __abs__K  s   zBaseMaskedArray.__abs__npt.DTypeLike | Nonerj   objectc                 C  sz   |t ju rtj}|du rt}| jr3t|s&t|s&|tju r&td| d| j	
|}||| j< |S | 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.rz   )r	   
no_default
libmissingNAr   _hasnar"   r$   rU   rE   astyperG   )rV   rQ   rJ   rj   r   rW   rW   rX   to_numpyP  s&   
B

zBaseMaskedArray.to_numpy.npt.DTypeLikec                 C  re   ra   rW   rV   rQ   rJ   rW   rW   rX   r     rh   zBaseMaskedArray.astyper   r6   c                 C  re   ra   rW   r   rW   rW   rX   r     rh   r   r   c                 C  re   ra   rW   r   rW   rW   rX   r     rh   Tc                 C  s  t |}t|| jr|r|  S | S t|tr8| jj|j|d}|| ju r(| j	n| j	 }|
 }|||ddS t|trI|
 }|j| ||dS t|rQtj}nt|r[td}ntj}t|ri| jritdt|rt| jrttd| j|||d}| jjdkrt||ddS |S )	Nrz   FrZ   NaTzcannot convert NA to integerz cannot convert float NaN to bool)rQ   rj   rJ   r}   )r%   r   rQ   rJ   rN   r&   rE   r   numpy_dtyperG   construct_array_typer   r_   r   rO   nanr   
datetime64r	   r   r    r   rU   r   r   r~   r   )rV   rQ   rJ   r   rI   r[   eaclsrj   rW   rW   rX   r     s4   

i  NpDtype | Nonec                 C  s   | j |dS )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        r   )r   )rV   rQ   rW   rW   rX   	__array__  s   zBaseMaskedArray.__array__ztuple[type, ...]_HANDLED_TYPESufuncnp.ufuncrt   r   c           	        s`  | 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|| qe fddt|||i |}|jdkrtfdd	|D S |dkr| j r| jS |S |S )
NoutrW   reducer   c                   s   ddl m}m}m} t| jr  }|| |S t| jr&  }|| |S t| jr@  }| jt	j
kr;| t	j} || |S t	j|  < | S )Nr   )r<   FloatingArrayIntegerArray)pandas.core.arraysr<   r   r   r   rQ   rJ   r    r   rO   float16r   float32r   )xr<   r   r   mrI   rW   rX   reconstruct  s   






z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructr   c                 3  s    | ]} |V  qd S ra   rW   .0r   )r   rW   rX   	<genexpr>2  s    z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)getrN   r   rA   NotImplementedr/   !maybe_dispatch_ufunc_to_dunder_opr-   dispatch_ufunc_with_outdispatch_reduction_ufuncrO   zerosro   rK   rG   appendrE   getattrnouttuplerp   	_na_value)	rV   r   rt   inputsr   r   r   resultinputs2rW   )rI   r   rX   __array_ufunc__  s`   



zBaseMaskedArray.__array_ufunc__c                 C  s   ddl }|j| j| j|dS )z6
        Convert myself into a pyarrow Array.
        r   N)rI   rk   )pyarrowarrayrE   rG   )rV   rk   parW   rW   rX   __arrow_array__;  s   zBaseMaskedArray.__arrow_array__c                 C  
   | j  S ra   )rG   rp   rb   rW   rW   rX   r   C  s   
zBaseMaskedArray._hasnanpt.NDArray[np.bool_] | Nonec                 C  s6   |d u r| j  }|tju r|dB }|S | j |B }|S )NT)rG   rJ   r   r   )rV   rI   otherrW   rW   rX   _propagate_maskL  s   


zBaseMaskedArray._propagate_maskc           	      C  s>  |j }d }t|tr|j|j}}nt|r)t|ts t|}|j	dkr)t
dt|t| f}t|}t|}|dv rIt|tjrIt|}| ||}|tju rt| j}| jjdkr{|dv rlt
d| d|dv rsd	}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 sw   Y  |dkrt| jdk| j @ d|}|d urt|dk| @ d|}nB|tjurt|dkd|}n3|dkr|d urt|dk| @ d|}n|tjurt|dkd|}t| jdk| j @ d|}| ||S )Nr   (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int8rK   r   r}   )r   u)r   r   ignoreallr   Fr   r   )__name__rN   rA   rE   rG   r!   r6   rO   asarrayrm   NotImplementedErrorr/   maybe_prepare_scalar_for_opro   get_array_opr7   rR   rK   r   r   r   	ones_likerQ   r~   r   float64errstatewherer   )	rV   r   opop_nameomaskpd_oprI   r   rQ   rW   rW   rX   _arith_methodX  s`   









zBaseMaskedArray._arith_methodr<   c              	   C  sF  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}nKt ? tdd	t tjdd
 t| jd|j d}||}W d    n1 sww   Y  |tu rt| j||}W d    n1 sw   Y  | ||}|||ddS )Nr   r;   r   r   zLengths must match to comparerK   r   r   elementwiser   __Frz   )r   r<   rN   rA   rE   rG   r!   rO   r   rm   r   ro   rU   r   r   r   rT   oneswarningscatch_warningsfilterwarningsFutureWarningr   r   r   r   r9   r   )rV   r   r   r<   rI   r   rt   rW   rW   rX   _cmp_method  s2   





zBaseMaskedArray._cmp_methodc           	      C  s   t |tr|\}}| ||| ||fS t|jr'ddlm} |||ddS t|jr9ddlm} |||ddS |jdkrXddlm	} t ||sN|
|}|jd||< |S t|jrjdd	lm} |||ddS tj||< |S )
z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r   )r   Frz   r;   ztimedelta64[ns])TimedeltaArrayr   r   )rN   r   r   r   rQ   r   r   r   r<   r  _simple_newrk   r    r   rO   r   )	rV   r   rI   divr   r   r<   r  r   rW   rW   rX   r     s,   









z"BaseMaskedArray._maybe_mask_resultc                 C  r   ra   )rG   rJ   rb   rW   rW   rX   r*     r   zBaseMaskedArray.isnac                 C  r   ra   rQ   rj   rb   rW   rW   rX   r     rc   zBaseMaskedArray._na_valuec                 C  s   | j j| jj S ra   )rE   nbytesrG   rb   rW   rW   rX   r  	  s   zBaseMaskedArray.nbytes	to_concatSequence[BaseMaskedArrayT]c                 C  s:   t jdd |D |d}t jdd |D |d}| ||S )Nc                 S     g | ]}|j qS rW   rE   r   rW   rW   rX   
<listcomp>      z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r   c                 S  r  rW   )rG   r   rW   rW   rX   r    r  )rO   concatenate)r[   r  r   r   rI   rW   rW   rX   _concat_same_type  s   
z!BaseMaskedArray._concat_same_type)
allow_fill
fill_valuer   r  r  Scalar | Nonec          	      C  sv   t |r| jn|}t| j||||d}t| j|d||d}|r2t|r2t|dk}|||< ||A }t| ||ddS )N)r  r  r   TFrz   )	r*   rC   r2   rE   rG   r+   rO   r   rk   )	rV   indexerr  r  r   data_fill_valuer   rI   	fill_maskrW   rW   rX   r2     s    
zBaseMaskedArray.takec                   sr   ddl m} t|}t j|} jr)t|jo#t	 fdd|D }|| j
< tj jjtd}|||ddS )Nr   r;   c                 3  s    | ]	}| j ju V  qd S ra   r  )r   valrb   rW   rX   r   E  s    
z'BaseMaskedArray.isin.<locals>.<genexpr>r   Frz   )r   r<   rO   r   r1   rE   r   r"   rQ   rp   rG   r   rT   rK   )rV   rH   r<   
values_arrr   values_have_NArI   rW   rb   rX   r1   ;  s   

zBaseMaskedArray.isinc                 C  s0   | j | j}}| }| }t| ||ddS )NFrz   )rE   rG   rJ   rk   )rV   r   rI   rW   rW   rX   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
        Frz   )algosunique_with_maskrE   rG   rk   )rV   uniquesrI   rW   rW   rX   uniqueV  s   zBaseMaskedArray.uniqueleftrs   $NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterr=   npt.NDArray[np.intp] | np.intpc                 C  s4   | j rtdt|tr|t}| jj|||dS )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)r%  r'  )r   rU   rN   r6   r   r   rE   searchsorted)rV   rs   r%  r'  rW   rW   rX   r)  a  s   

zBaseMaskedArray.searchsortedna_sentinelint | lib.NoDefaultuse_na_sentinelbool | lib.NoDefault!tuple[np.ndarray, ExtensionArray]c                 C  s  t ||}| j}| j}|d u rdn|}t|||d\}}|j| jjks,J |j| jf| }	|d us6|	s;t|}
nt|d }
t	j
|
td}|d u r|	r| }|dkr\t	d}n
|d |  d }|||k  d7  < |||dk< t	||d}d||< t| ||}||fS )Nr  )r*  rI   r   r   r   T)r  resolve_na_sentinelrE   rG   r0   rQ   r   rp   ro   rO   r   rK   argmaxintpmaxinsertrk   )rV   r*  r,  resolved_na_sentinelarrrI   na_sentinel_argcodesr!  has_nasizeuniques_maskna_indexna_code
uniques_earW   rW   rX   	factorizer  s,   
zBaseMaskedArray.factorizec                 C  s   | j S ra   r  rb   rW   rW   rX   _values_for_argsort  s   z#BaseMaskedArray._values_for_argsortdropnar:   c                 C  s  ddl m}m} ddlm} |r1tj| jd| jd\}}|||d}|j	
| j|_	|
d}|S | j| j  }|| }	|	j	}
|rG|	j}n"t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   )indexInt64r   int64r   Nr  rK   )pandasrA  r:   pandas.arraysr   r  value_counts_arraylikerE   rG   rB  r   rQ   value_counts_valuesrO   emptyro   sumr3  rj   r   )rV   r@  rA  r:   r   keyscountsresr   rH  rB  rI   counts_arrayrW   rW   rX   rH    s.   



zBaseMaskedArray.value_countsc                 C  sb   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S )NFT)dtype_equal)rk   rQ   rO   array_equalrG   rE   r(   )rV   r   r#  rightrW   rW   rX   equals  s   zBaseMaskedArray.equalsqsnpt.NDArray[np.float64]interpolationc                 C  sz   t | j| jtj||d}| jr.| jdkrt|  	 r%tj
|jt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.
        )rI   r  rT  rV     r   r   )r4   rE   rG   rO   r   r   rm   r   r*   r   r  rT   rK   r   r   )rV   rT  rV  rN  out_maskrW   rW   rX   	_quantile  s   

zBaseMaskedArray._quantile)skipnanamerZ  c                K  s   |dv rt | |d	d|i|S | j}| j}|dv r,t t|}|||fd|i|}|S | jr7| jdtjd}t td| }||fd||d|}t	|rRt
jS |S )
N>   r   rp   r2  minrK  prodrZ  >   meanr   )rj   r   r   )r   rZ  rI   rW   )r   rE   rG   r3   r   r   rO   r   r.   isnanr   r   )rV   r[  rZ  r   r   rI   r   r   rW   rW   rX   _reduce  s   

zBaseMaskedArray._reducec                 K  sF   t |tjr!|d }|r| jj|d}n| jj|d}| ||S |S )Nr   r   )rN   rO   rP   rG   r   rp   r   )rV   r[  r   rZ  r   r   rI   rW   rW   rX   _wrap_reduction_result(  s   z&BaseMaskedArray._wrap_reduction_resultrZ  	min_countr   
int | Nonec                K  s`   t d| d|v r|d d urt|d tj| j| j|||d}| jd|f||d|S )NrW   r   rb  rK  rZ  r   )	r   validate_sumr   popr3   rK  rE   rG   ra  rV   rZ  rc  r   r   r   rW   rW   rX   rK  4  s&   
zBaseMaskedArray.sumc                K  s>   t d| tj| j| j|||d}| jd|f||d|S )NrW   rb  r]  re  )r   validate_prodr3   r]  rE   rG   ra  rh  rW   rW   rX   r]  I  s   zBaseMaskedArray.prodre  c                K  "   t d| tj| j| j||dS NrW   re  )r   validate_minr3   r\  rE   rG   rV   rZ  r   r   rW   rW   rX   r\  V     zBaseMaskedArray.minc                K  rj  rk  )r   validate_maxr3   r2  rE   rG   rm  rW   rW   rX   r2  _  rn  zBaseMaskedArray.maxc                K  sj   | dd td| | j }t|| j| j |	 }|r"|S |s/t
| dks/| j	 s1|S | jj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   NrW   r   )rg  r   validate_anyrE   rJ   rO   putmaskrG   _falsey_valuerp   ro   rQ   rj   rV   rZ  r   rH   r   rW   rW   rX   rp   h  s   >
zBaseMaskedArray.anyc                K  sj   | dd td| | j }t|| j| j |	 }|r"|S |r/t
| dks/| j s1|S | jj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   NrW   r   )rg  r   validate_allrE   rJ   rO   rq  rG   _truthy_valuer   ro   rp   rQ   rj   rs  rW   rW   rX   r     s   >
zBaseMaskedArray.all)F)rH   rD   rI   rF   rJ   rK   rL   rM   )r[   r\   rJ   rK   rL   r@   )rL   r&   )rd   r   rL   r   )rV   r@   rd   r   rL   r@   )rV   r@   rd   r   rL   ri   )NNN)rV   r@   rL   r@   )rQ   r   rJ   rK   rL   r{   )rL   rM   )rL   r   )rL   r   )r   )rV   r@   r   r   rL   r@   )r   r   )rQ   r   rJ   rK   rj   r   rL   rD   ).)rQ   r   rJ   rK   rL   rD   )rQ   r   rJ   rK   rL   r6   )rQ   r   rJ   rK   rL   r   )Tra   )rQ   r   rL   rD   )r   r   rt   r   )rL   rK   )rI   r   rL   rF   )rL   r<   )rL   rD   )r[   r\   r  r  r   r   rL   r@   )
rV   r@   r  rK   r  r  r   r   rL   r@   )r#  N)rs   r$  r%  r&  r'  r=   rL   r(  )r*  r+  r,  r-  rL   r.  )r@  rK   rL   r:   )rT  rU  rV  r   rL   rA   )r[  r   rZ  rK   )r[  r   )r   rd  )rZ  rK   )Gr   
__module____qualname____doc____annotations__r   ru  rr  rY   classmethodr_   propertyrQ   r   rg   r   r6   ry   r]   r   r   r   r   rT   rm   r   r   r   r   rr   r   r   r   r   r   r	   r   r   r   __array_priority__r   r   r   r   r   r   _logical_methodr  r   r*   r   r  r  r2   r1   rJ   r"  r)  r>  r?  rH  rS  rY  r`  ra  rK  r]  r\  r2  rp   r   rW   rW   rW   rX   rA   \   s   
 






!


X/

M
T
(
,

$

)7
'
		Q)\
__future__r   typingr   r   r   r   r   r   r  numpyrO   pandas._libsr	   r
   r   pandas._typingr   r   r   r   r   r   r   r   r   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._validatorsr   pandas.core.dtypes.astyper   pandas.core.dtypes.baser   pandas.core.dtypes.commonr   r   r   r   r   r    r!   r"   r#   r$   r%   pandas.core.dtypes.dtypesr&   pandas.core.dtypes.inferencer'   pandas.core.dtypes.missingr(   r)   r*   r+   pandas.corer,   r  r-   r.   r/   pandas.core.algorithmsr0   r1   r2   pandas.core.array_algosr3    pandas.core.array_algos.quantiler4   pandas.core.arrayliker5   r   r6   pandas.core.constructionr7   pandas.core.indexersr8   pandas.core.opsr9   rE  r:   r<   r=   r>   pandas.compat.numpyr?   r   r@   rA   rW   rW   rW   rX   <module>   s>     04