a
    OfR                     @  sD  d dl mZ d dlmZmZmZmZmZ d dlZd dl	Z
d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m!Z!m"Z" d dl#m$Z$ d d	l%m&Z& d d
l'm(Z( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z;m<Z<mZm=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ erd dl[m\Z\m]Z] d dl^m_Z_ d dl`maZa d dlmbZbmcZc d dl`mdZd d dlemfZg G d d! d!eKeOZhd"d#d$d%d&ZidS )'    )annotations)TYPE_CHECKINGAnyCallableLiteraloverloadN)libmissing)is_supported_dtype)	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSelfSequenceIndexerShapenpt)IS64is_platform_windowsAbstractMethodError)doc)validate_fillna_kwargs)ExtensionDtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker	   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexer)invalid_comparison)
hash_array)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLikeFloatingArray)functionc                      sh  e Zd ZU dZded< ded< ded< eZeZedddd	d
dZ	ddddddddZ
eddddddddZeeejdddddZddddddZed d!d"d#Zed$d%d&d'd(Zed)dd&d*d(Zd+d,d&d-d(Zddd.d/d0d1d2ddd3d4d5Zeejdd1ddd6d7d8Zedd9d:dd;d<d=d>Zd?d@ Zdd!dAdBZdd! fdCdDZdEd!dFdGZdHd!dIdJZedd!dKdLZedHd!dMdNZdd!dOdPZddRddSdTdUZdd!dVdWZ dd!dXdYZ!edd!dZd[Z"ddHd\d]d^Z#dd!d_d`Z$dd!dadbZ%dd!dcddZ&dd!dedfZ'dd!dgdhZ(dde)j*fdiddjddkdldmZ+eej,dndo Z,eddqddd<drdsZ-eddddtd<dudsZ-eddvddwd<dxdsZ-d	dvddwd<dydsZ-dzZ.d
d{d|dd<d}d~Z/ded< dddddZ0dddZ1edd!ddZ2dddddZ3dd Z4e4Z5dd!ddZ6dddddZ7dd!ddZ8edd Z9edHd!ddZ:edddRddddZ;dddddddZ<dddQddddRddddZ=dwddddZ>dd!ddZ?eej@ddddddZ@dd!ddZAeejBddddddddZBeejCddddddZCeejDdd!ddÄZDddddŜddǄZEddddŜddɄZFeejGdd!dd˄ZGddd d͜ddτZHd.ddМddddќddӄZIddԜddքZJdd؄ ZKddԜddڄZLd.dQdQdۜddHddۜddބZMd.dQdQdۜddHddۜddZNd.dQddddddZOd.dQdddddHdddZPd.dQdddddHdddZQd.dQddddddZRd.dQddddddZSdddZTd.dQddddddZUd.dQddddddZVddHdddddZWd.dddd dddZXdddHdHdddd ZY  ZZS (  BaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   _internal_fill_value
np.ndarray_dataznpt.NDArray[np.bool_]_maskr   )valuesmaskreturnc                 C  s   t | }||_||_|S N)rJ   __new__rM   rN   )clsrO   rP   result rV   R/var/www/ai-form-bot/venv/lib/python3.9/site-packages/pandas/core/arrays/masked.py_simple_new|   s    
zBaseMaskedArray._simple_newFboolNone)rO   rP   copyrQ   c                 C  sX   t |tjr|jtjks td|j|jkr4td|rH| }| }|| _	|| _
d S )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)
isinstancenpndarraydtypebool_	TypeErrorshape
ValueErrorr[   rM   rN   )selfrO   rP   r[   rV   rV   rW   __init__   s    zBaseMaskedArray.__init__Nr_   r[   )r[   rQ   c                C  s   | j |||d\}}| ||S )Nrf   )_coerce_to_array)rT   Zscalarsr_   r[   rO   rP   rV   rV   rW   _from_sequence   s    zBaseMaskedArray._from_sequencer   r   )rb   r_   c                 C  s\   t j||jd}|| j t j|td}| ||}t|| rH||jkrXt	d| d|S )Nr_   z5Default 'empty' implementation is invalid for dtype='')
r]   emptytypefillrK   onesrY   r\   r_   NotImplementedError)rT   rb   r_   rO   rP   rU   rV   rV   rW   _empty   s    

zBaseMaskedArray._emptyzCallable[[Any], str | None])boxedrQ   c                 C  s   t S rR   )str)rd   rq   rV   rV   rW   
_formatter   s    zBaseMaskedArray._formatterr&   )rQ   c                 C  s   t | d S rR   r   rd   rV   rV   rW   r_      s    zBaseMaskedArray.dtyper   r   )itemrQ   c                 C  s   d S rR   rV   rd   ru   rV   rV   rW   __getitem__   s    zBaseMaskedArray.__getitem__r   c                 C  s   d S rR   rV   rv   rV   rV   rW   rw      s    r   z
Self | Anyc                 C  sD   t | |}| j| }t|r2|r(| jjS | j| S | | j| |S rR   )r=   rN   r    r_   na_valuerM   rX   )rd   ru   ZnewmaskrV   rV   rW   rw      s    


T)limit
limit_arear[   r   z
int | Nonez#Literal['inside', 'outside'] | None)methodry   rz   r[   rQ   c                C  sT  | j }| r<tj|| jd}| jj}|j}|rD| }| }n|d urT| }||||d |d ur | s |j}| }	|		 }
t
|	|	d d d 	  d }|dkr|d |
  |d |
 O  < ||d d   ||d d  O  < n.|dkr ||
d |  ||
d | O  < |r6| |j|jS | S n|rL|  }n| }|S )Nndimry   rP      ZinsideZoutside)rN   anyr	   get_fill_funcr}   rM   Tr[   allargmaxlenrX   )rd   r{   ry   rz   r[   rP   funcnpvaluesnew_maskZneg_maskfirstlast
new_valuesrV   rV   rW   _pad_or_backfill   s8    

&
$
z BaseMaskedArray._pad_or_backfill)ry   r[   rQ   c           
      C  s   t ||\}}| j}t||t| }| r|d urtj|| jd}| jj	}|j	}|rh|
 }|
 }||||d | |j	|j	S |r| 
 }	n| d d  }	||	|< n|r| 
 }	n| d d  }	|	S )Nr|   r~   )r   rN   r	   Zcheck_value_sizer   r   r   r}   rM   r   r[   rX   )
rd   valuer{   ry   r[   rP   r   r   r   r   rV   rV   rW   fillna   s*    


zBaseMaskedArray.fillnar[   r   ztuple[np.ndarray, np.ndarray])r_   r[   rQ   c                C  s   t | d S rR   r   )rT   rO   r_   r[   rV   rV   rW   rg     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)r_   kindr   r    
is_integeris_floatra   rr   )rd   r   r   rV   rV   rW   _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 )NTFri   )r=   r#   r(   r_   rN   r   rM   rg   )rd   keyr   rP   rV   rV   rW   __setitem__3  s    




zBaseMaskedArray.__setitem__c                   sX   t |rH|| jjurH| jjjdkrHt|rHtt	| j| j
 @  S tt |S )Nr   )r)   r_   rx   rM   r   r   r   rY   r]   isnanrN   r   super__contains__)rd   r   	__class__rV   rW   r   D  s    zBaseMaskedArray.__contains__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 )Nr   )	r}   _hasnarM   r_   rx   ziprN   ranger   )rd   valrx   Zisna_irV   rV   rW   __iter__L  s    



zBaseMaskedArray.__iter__intc                 C  s
   t | jS rR   )r   rM   rt   rV   rV   rW   __len__\  s    zBaseMaskedArray.__len__c                 C  s   | j jS rR   )rM   rb   rt   rV   rV   rW   rb   _  s    zBaseMaskedArray.shapec                 C  s   | j jS rR   )rM   r}   rt   rV   rV   rW   r}   c  s    zBaseMaskedArray.ndimc                 C  s(   | j ||}| j||}| ||S rR   )rM   swapaxesrN   rX   )rd   Zaxis1Zaxis2datarP   rV   rV   rW   r   g  s    zBaseMaskedArray.swapaxesr   r   )axisrQ   c                 C  s0   t j| j||d}t j| j||d}| ||S Nr   )r]   deleterM   rN   rX   )rd   locr   r   rP   rV   rV   rW   r   l  s    zBaseMaskedArray.deletec                 O  s0   | j j|i |}| jj|i |}| ||S rR   )rM   reshaperN   rX   rd   argskwargsr   rP   rV   rV   rW   r   q  s    zBaseMaskedArray.reshapec                 O  s2   | j j|i |}| jj|i |}t| ||S rR   )rM   ravelrN   rl   r   rV   rV   rW   r   v  s    zBaseMaskedArray.ravelc                 C  s   |  | jj| jjS rR   )rX   rM   r   rN   rt   rV   rV   rW   r   |  s    zBaseMaskedArray.T)decimalsc                 O  sF   | j jdkr| S t|| tj| jfd|i|}| || j	 S )a  
        Round each value in the array a to the given number of decimals.

        Parameters
        ----------
        decimals : int, default 0
            Number of decimal places to round to. If decimals is negative,
            it specifies the number of positions to the left of the decimal point.
        *args, **kwargs
            Additional arguments and keywords have no effect but might be
            accepted for compatibility with NumPy.

        Returns
        -------
        NumericArray
            Rounded values of the NumericArray.

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r   r   )
r_   r   nvZvalidate_roundr]   roundrM   _maybe_mask_resultrN   r[   )rd   r   r   r   rO   rV   rV   rW   r     s
    zBaseMaskedArray.roundc                 C  s   |  | j | j S rR   rX   rM   rN   r[   rt   rV   rV   rW   
__invert__  s    zBaseMaskedArray.__invert__c                 C  s   |  | j | j S rR   r   rt   rV   rV   rW   __neg__  s    zBaseMaskedArray.__neg__c                 C  s   |   S rR   r   rt   rV   rV   rW   __pos__  s    zBaseMaskedArray.__pos__c                 C  s   |  t| j| j S rR   )rX   absrM   rN   r[   rt   rV   rV   rW   __abs__  s    zBaseMaskedArray.__abs__c                 C  s   t j| tdS )Nri   )r]   asarrayobjectrt   rV   rV   rW   _values_for_json  s    z BaseMaskedArray._values_for_jsonznpt.DTypeLike | Noner   )r_   r[   rx   rQ   c                 C  s   | j }t| |||\}}|du r$t}|r|tkrRt|sR|tju rRtd| dt * tj	dt
d | j|}W d   n1 s0    Y  ||| j< nFt . tj	dt
d | jj||d}W d   n1 s0    Y  |S )aF  
        Convert to a NumPy Array.

        By default converts to an object-dtype NumPy array. Specify the `dtype` and
        `na_value` keywords to customize the conversion.

        Parameters
        ----------
        dtype : dtype, default object
            The numpy dtype to convert to.
        copy : bool, default False
            Whether to ensure that the returned value is a not a view on
            the array. Note that ``copy=False`` does not *ensure* that
            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
            a copy is made, even if not strictly necessary. This is typically
            only possible when no missing values are present and `dtype`
            is the equivalent numpy dtype.
        na_value : scalar, optional
             Scalar missing value indicator to use in numpy array. Defaults
             to the native missing value indicator of this array (pd.NA).

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        An object-dtype is the default result

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a.to_numpy()
        array([True, False, <NA>], dtype=object)

        When no missing values are present, an equivalent dtype can be used.

        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
        array([ True, False])
        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
        array([1, 2])

        However, requesting such dtype will raise a ValueError if
        missing values are present and the default missing value :attr:`NA`
        is used.

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a
        <BooleanArray>
        [True, False, <NA>]
        Length: 3, dtype: boolean

        >>> a.to_numpy(dtype="bool")
        Traceback (most recent call last):
        ...
        ValueError: cannot convert to bool numpy array in presence of missing values

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.ignorecategoryr   )r   r8   r   r$   
libmissingNArc   warningscatch_warningsfilterwarningsRuntimeWarningrM   astyperN   )rd   r_   r[   rx   Zhasnar   rV   rV   rW   to_numpy  s,    B

*
.zBaseMaskedArray.to_numpyc                 C  s>   | j dkrdd | D S | jr"d n| jj}| j|tjd S )Nr   c                 S  s   g | ]}|  qS rV   )tolist.0xrV   rV   rW   
<listcomp>      z*BaseMaskedArray.tolist.<locals>.<listcomp>r_   rx   )r}   r   rM   r_   r   r   r   r   )rd   r_   rV   rV   rW   r     s    
zBaseMaskedArray.tolist.znpt.DTypeLikec                 C  s   d S rR   rV   rd   r_   r[   rV   rV   rW   r     s    zBaseMaskedArray.astyper9   c                 C  s   d S rR   rV   r   rV   rV   rW   r     s    r   r   c                 C  s   d S rR   rV   r   rV   rV   rW   r      s    c                 C  s@  t |}|| jkr"|r|  S | S t|trt 0 tjdtd | j	j
|j|d}W d    n1 sj0    Y  || j	u r| jn| j }| }|||ddS t|tr| }|j| ||dS |jdkrtj}n|jdkrtd}ntj}|jd	v r| jrtd
|jdkr,| jr,td| j|||d}|S )Nr   r   r   Frf   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)r_   rx   r[   )r%   r_   r[   r\   r&   r   r   r   r   rM   r   numpy_dtyperN   construct_array_typer   rh   r   r]   nanZ
datetime64r   
no_defaultr   rc   r   )rd   r_   r[   r   rP   rT   Zeaclsrx   rV   rV   rW   r   $  s4    


0


i  zNpDtype | Nonezbool | Nonec                 C  s   | j |dS )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        ri   )r   r   rV   rV   rW   	__array__T  s    zBaseMaskedArray.__array__ztuple[type, ...]_HANDLED_TYPESznp.ufuncrr   )ufuncr{   c           	        sp  | dd}|| D ]}t|| jtf st  S qtj| ||g|R i |}|tur\|S d|v rtj| ||g|R i |S |dkrtj| ||g|R i |}|tur|S t	j
t| td g }|D ]0}t|tr |jO  ||j q|| qdd fddt|||i |}|jd	krDtfd
d|D S |dkrd| j r`| jS |S |S d S )NoutrV   reduceri   rL   )r   c                   s   ddl m}m}m} | jjdkr2  }|| |S | jjdv rP  }|| |S | jjdkr  }| jtjkr|| 	tj
} || |S tj|  < | S )Nr   )rD   rH   IntegerArrayr   r   r   )pandas.core.arraysrD   rH   r   r_   r   r[   r]   Zfloat16r   float32r   )r   rD   rH   r   mrP   rV   rW   reconstruct  s    



z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructr   c                 3  s   | ]} |V  qd S rR   rV   r   )r   rV   rW   	<genexpr>  r   z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)getr\   r   rJ   NotImplementedr,   Z!maybe_dispatch_ufunc_to_dunder_opZdispatch_ufunc_with_outZdispatch_reduction_ufuncr]   zerosr   rY   rN   appendrM   getattrZnouttupler   	_na_value)	rd   r   r{   inputsr   r   r   rU   Zinputs2rV   )rP   r   rW   __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)rP   rl   )Zpyarrowr:   rM   rN   )rd   rl   parV   rV   rW   __arrow_array__  s    zBaseMaskedArray.__arrow_array__c                 C  s
   | j  S rR   )rN   r   rt   rV   rV   rW   r     s    zBaseMaskedArray._hasnaznpt.NDArray[np.bool_] | None)rP   rQ   c                 C  sZ   |d u rL| j  }|tju r&|dB }qVt|rVt|t|krV|t|B }n
| j |B }|S )NT)rN   r[   r   r   r"   r   r)   )rd   rP   otherrV   rV   rW   _propagate_mask  s    



zBaseMaskedArray._propagate_maskc           	      C  s  |j }d }t|ds@t|r@t|t| kr@t|}t|dd}t|trZ|j|j	 }}n.t|rt|t
svt|}|jdkrtdt|t| f}t|}t|}|dv rt|tjrt|}| ||}|tju rZt| j}| jjdkr4|dv rtd	| d
|dv r$d}nd}||}n$d|v r| jjdkr|tj}nV| jjdv rv|dv rv|}tjdd || j|}W d    n1 s0    Y  |dkrt| jdk| j	 @ d|}|d urt|dk| @ d|}n|tjurt|dkd|}nh|dkr|d urHt|dk| @ d|}n|tjurft|dkd|}t| jdk| j	 @ d|}| ||S )Nr_   T)Zextract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   r   Z	rfloordivr   Zrtruedivtruedivfloordivz
operator 'z!' not implemented for bool dtypes>   ZrmodmodZint8rY   r   r   r   )r   r   r   )r   r   Fr   r   ) __name__hasattrr"   r   pd_arrayr<   r\   rJ   rM   rN   r9   r]   r   r}   ro   r.   Zmaybe_prepare_scalar_for_opZget_array_opr;   r`   rY   r   r   r   Z	ones_liker_   r   r   float64Zerrstatewherer   )	rd   r   opZop_nameZomaskZpd_oprP   rU   r_   rV   rV   rW   _arith_method  sj    








,



zBaseMaskedArray._arith_methodrD   c                 C  s*  ddl m} d }t|tr*|j|j }}n<t|rft|}|j	dkrNt
dt| t|krftd|tju rtj| jjdd}tj| jjdd}nzt ` tdd	t tdd	t t| jd
|j d
}||}|tu rt| j||}W d    n1 s0    Y  | ||}|||ddS )Nr   rC   r   r   zLengths must match to comparerY   ri   r   Zelementwise__Fr   )r   rD   r\   rJ   rM   rN   r"   r]   r   r}   ro   r   rc   r   r   r   rb   rn   r   r   r   FutureWarningDeprecationWarningr   r   r   r>   r   )rd   r   r   rD   rP   rU   r{   rV   rV   rW   _cmp_method,  s,    




.zBaseMaskedArray._cmp_methodz*np.ndarray | tuple[np.ndarray, np.ndarray])rU   rP   c           	      C  s   t |tr*|\}}| ||| ||fS |jjdkrPddlm} |||ddS |jjdkrvddlm} |||ddS t	|jdrt
|jrdd	lm} |jd
||< t ||s|j||jdS |S |jjdv 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   rG   Fr   r   rC   r   )TimedeltaArrayr   ri   r   r   N)r\   r   r   r_   r   r   rH   rD   r   Zis_np_dtyper
   r  rl   rX   r   r]   r   )	rd   rU   rP   divr   rH   rD   r  r   rV   rV   rW   r   T  s,    	




z"BaseMaskedArray._maybe_mask_resultc                 C  s
   | j  S rR   )rN   r[   rt   rV   rV   rW   r)     s    zBaseMaskedArray.isnac                 C  s   | j jS rR   r   rt   rV   rV   rW   r     s    zBaseMaskedArray._na_valuec                 C  s   | j j| jj S rR   )rM   nbytesrN   rt   rV   rV   rW   r    s    zBaseMaskedArray.nbyteszSequence[Self])	to_concatr   rQ   c                 C  s:   t jdd |D |d}t jdd |D |d}| ||S )Nc                 S  s   g | ]
}|j qS rV   rM   r   rV   rV   rW   r     r   z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r   c                 S  s   g | ]
}|j qS rV   )rN   r   rV   rV   rW   r     r   )r]   concatenate)rT   r  r   r   rP   rV   rV   rW   _concat_same_type  s    z!BaseMaskedArray._concat_same_typeznpt.NDArray[np.uint64])encodinghash_key
categorizerQ   c                C  s*   t | j|||d}t| jj||  < |S )N)r  r  r  )r?   rM   hashr_   rx   r)   )rd   r  r  r  Zhashed_arrayrV   rV   rW   _hash_pandas_object  s
    
z#BaseMaskedArray._hash_pandas_object)
allow_fill
fill_valuer   zScalar | None)r  r  r   rQ   c          	      C  sp   t |r| jn|}t| j||||d}t| j|d||d}|rdt|rdt|dk}|||< ||A }| ||S )N)r  r  r   Tr   )	r)   rK   r3   rM   rN   r*   r]   r   rX   )	rd   Zindexerr  r  r   Zdata_fill_valuerU   rP   Z	fill_maskrV   rV   rW   r3     s     
zBaseMaskedArray.take)rO   rQ   c                   sr   ddl m} t|}t j|} jrR|jtkoFt	 fdd|D }|| j
< tj jjtd}|||ddS )Nr   rC   c                 3  s   | ]}| j ju V  qd S rR   r   )r   r   rt   rV   rW   r     s   z'BaseMaskedArray.isin.<locals>.<genexpr>ri   Fr   )r   rD   r]   r   r0   rM   r   r_   r   r   rN   r   rb   rY   )rd   rO   rD   Z
values_arrrU   Zvalues_have_NArP   rV   rt   rW   r0     s    

zBaseMaskedArray.isinc                 C  s    | j  }| j }| ||S rR   )rM   r[   rN   rX   )rd   r   rP   rV   rV   rW   r[     s    

zBaseMaskedArray.copyr   zLiteral['first', 'last', False])keeprQ   c                 C  s   | j }| j}tj|||dS )N)r  rP   )rM   rN   algos
duplicated)rd   r  rO   rP   rV   rV   rW   r    s    zBaseMaskedArray.duplicatedc                 C  s    t | j| j\}}| ||S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )r  Zunique_with_maskrM   rN   rX   )rd   uniquesrP   rV   rV   rW   unique  s    zBaseMaskedArray.uniqueleftz$NumpyValueArrayLike | ExtensionArrayzLiteral['left', 'right']zNumpySorter | Noneznpt.NDArray[np.intp] | np.intp)r   sidesorterrQ   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   rc   r\   r9   r   r   rM   searchsorted)rd   r   r  r  rV   rV   rW   r    s    

zBaseMaskedArray.searchsortedz!tuple[np.ndarray, ExtensionArray])use_na_sentinelrQ   c                 C  s   | j }| j}t|d|d\}}|j| jjks<J |j| jf| }|sL|sVt|}nt|d }tj|t	d}|s|r|
 }	|	dkrtd}
n|d |	  d }
|||
k  d7  < |
||dk< t||
d}d||
< | ||}||fS )NT)r  rP   r   ri   r   r   )rM   rN   r/   r_   r   r   r   r]   r   rY   r   ZintpmaxinsertrX   )rd   r  arrrP   codesr  Zhas_nasizeZuniques_maskZna_indexZna_codeZ
uniques_earV   rV   rW   	factorize  s(    
zBaseMaskedArray.factorizec                 C  s   | j S rR   r  rt   rV   rV   rW   _values_for_argsort'  s    z#BaseMaskedArray._values_for_argsortrB   )dropnarQ   c                 C  s   ddl m}m} ddlm} tj| j|| jd\}}}t	j
t|ft	jd}| }	|dkrdd|d< |||	}
|| j ||}||
|dd	d
S )aA  
        Returns a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )IndexrB   r  r#  rP   ri   Tr   countF)indexnamer[   )pandasr$  rB   Zpandas.arraysr   r  Zvalue_counts_arraylikerM   rN   r]   r   r   r`   r[   r_   r   )rd   r#  r$  rB   r   keysvalue_countsZ
na_counterZ
mask_indexrP   r  r'  rV   rV   rW   r+  +  s     

zBaseMaskedArray.value_countsc                 C  sZ   |r*t | j|| jd}tj|jtjd}nt | j|| jd\}}t| ||}||  S )Nr%  ri   )	r2   rM   rN   r]   r   rb   r`   rl   Zargsort)rd   r#  rU   Zres_maskrV   rV   rW   _modeS  s    zBaseMaskedArray._modec                 C  sd   t | t |krdS |j| jkr$dS t| j|js8dS | j| j  }|j|j  }t||dddS )NFT)Z
strict_nanZdtype_equal)rl   r_   r]   Zarray_equalrN   rM   r'   )rd   r   r  rightrV   rV   rW   equals\  s    zBaseMaskedArray.equalsznpt.NDArray[np.float64])qsinterpolationrQ   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.
        )rP   r  r/  r0     ri   r   )r6   rM   rN   r]   r   r   r}   ro   r)   r   rn   rb   rY   r!   r_   r   r   r   )rd   r/  r0  resZout_maskrV   rV   rW   	_quantilel  s"    


zBaseMaskedArray._quantile)skipnakeepdims)r(  r4  r5  c          
      K  s   |dv r"t | |f d|i|}n@| j}| j}t td| }|dd }	||f|	||d|}|rt|r~| j|dddS |d	}tj	d	t
d
}| ||S t|rtjS |S d S )N>	   r  meanminstdprodsumvarr   r   r4  r   r   )r   r4  rP   r   )r   )r(  r   	mask_sizer   ri   )r   rM   rN   r-   popr)   _wrap_na_resultr   r]   r   rY   r   r   r   )
rd   r(  r4  r5  r   rU   r   rP   r   r   rV   rV   rW   _reduce  s     
zBaseMaskedArray._reduce)r(  c                C  s>   t |tjr:|r | jj|d}n| jj|d}| ||S |S r   )r\   r]   r^   rN   r   r   r   )rd   r(  rU   r4  r   rP   rV   rV   rW   _wrap_reduction_result  s    z&BaseMaskedArray._wrap_reduction_resultc                C  s   t j|td}| jdkrdnd}|dv r.|}nZ|dv sB| jjdkrN| jjj}n:t pXt }|rbdnd	}|rnd
nd}	|||	|d| jj	 }t j
dg|d}
| j|
|dS )Nri   ZFloat32r   r   )r6  Zmedianr;  r8  ZskewZkurt)r7  r     Zint32Zint64Zuint32Zuint64)r   r   ur   r   r   )r]   rn   rY   r_   itemsizer   r(  r   r   r   r:   r   )rd   r(  r   r<  rP   Z
float_dtypZnp_dtypeZis_windows_or_32bitZint_dtypZ	uint_dtypr   rV   rV   rW   r>    s    zBaseMaskedArray._wrap_na_resultc                C  s>   |dkr,t |tjr,| |tj|jtdS | j||||dS )Nr   ri   r4  r   )r\   r]   r^   r   r   rb   rY   r@  )rd   r(  rU   r4  	min_countr   rV   rV   rW    _wrap_min_count_reduction_result  s    z0BaseMaskedArray._wrap_min_count_reduction_resultr4  rE  r   zAxisInt | Nonec                K  s8   t d| tj| j| j|||d}| jd||||dS )NrV   rG  r:  )r   Zvalidate_sumr5   r:  rM   rN   rF  rd   r4  rE  r   r   rU   rV   rV   rW   r:    s    
zBaseMaskedArray.sumc                K  s8   t d| tj| j| j|||d}| jd||||dS )NrV   rG  r9  )r   Zvalidate_prodr5   r9  rM   rN   rF  rH  rV   rV   rW   r9    s    
zBaseMaskedArray.prodrD  c                K  s4   t d| tj| j| j||d}| jd|||dS )NrV   rD  r6  )r   Zvalidate_meanr5   r6  rM   rN   r@  rd   r4  r   r   rU   rV   rV   rW   r6    s    zBaseMaskedArray.meanr   r4  r   ddofc                K  s:   t jd|dd tj| j| j|||d}| jd|||dS )NrV   r;  fnamerJ  rD  )r   validate_stat_ddof_funcr5   r;  rM   rN   r@  rd   r4  r   rK  r   rU   rV   rV   rW   r;    s    zBaseMaskedArray.varc                K  s:   t jd|dd tj| j| j|||d}| jd|||dS )NrV   r8  rL  rJ  rD  )r   rN  r5   r8  rM   rN   r@  rO  rV   rV   rW   r8    s    zBaseMaskedArray.stdc                K  s4   t d| tj| j| j||d}| jd|||dS )NrV   rD  r7  )r   Zvalidate_minr5   r7  rM   rN   r@  rI  rV   rV   rW   r7  %  s    zBaseMaskedArray.minc                K  s4   t d| tj| j| j||d}| jd|||dS )NrV   rD  r  )r   Zvalidate_maxr5   r  rM   rN   r@  rI  rV   rV   rW   r  /  s    zBaseMaskedArray.maxc                 C  s   t |  ||dS )N)	na_action)r1   r   )rd   ZmapperrP  rV   rV   rW   map9  s    zBaseMaskedArray.mapc                K  sb   t d| | j }t|| j| j | }|r8|S |sRt	| dksR| j sV|S | j
jS dS )aY  
        Return whether any element is truthy.

        Returns False unless there is at least one element that is truthy.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be False, as for an empty array.
            If `skipna` is False, the result will still be True if there is
            at least one element that is truthy, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.any : Numpy version of this method.
        BaseMaskedArray.all : Return whether all elements are truthy.

        Examples
        --------
        The result indicates whether any element is truthy (and by default
        skips NAs):

        >>> pd.array([True, False, True]).any()
        True
        >>> pd.array([True, False, pd.NA]).any()
        True
        >>> pd.array([False, False, pd.NA]).any()
        False
        >>> pd.array([], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="Float64").any()
        False

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        rV   r   N)r   Zvalidate_anyrM   r[   r]   putmaskrN   _falsey_valuer   r   r_   rx   rd   r4  r   r   rO   rU   rV   rV   rW   r   <  s    ?
zBaseMaskedArray.anyc                K  sf   t d| | j }t|| j| j |j|d}|r<|S |rVt	| dksV| j
 sZ|S | jjS dS )aL  
        Return whether all elements are truthy.

        Returns True unless there is at least one element that is falsey.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be True, as for an empty array.
            If `skipna` is False, the result will still be False if there is
            at least one element that is falsey, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.all : Numpy version of this method.
        BooleanArray.any : Return whether any element is truthy.

        Examples
        --------
        The result indicates whether all elements are truthy (and by default
        skips NAs):

        >>> pd.array([True, True, pd.NA]).all()
        True
        >>> pd.array([1, 1, pd.NA]).all()
        True
        >>> pd.array([True, False, pd.NA]).all()
        False
        >>> pd.array([], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="Float64").all()
        True

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        rV   r   r   N)r   Zvalidate_allrM   r[   r]   rR  rN   _truthy_valuer   r   r   r_   rx   rT  rV   rV   rW   r     s    ?
zBaseMaskedArray.allr   rH   )r{   r   r[   rQ   c             
   K  s   | j jdkr4|r&| j }	| j }
ql| j}	| j}
n8| j jdv r\d}| jd}	| j }
ntd| j  tj|	f|d|||||
d| |s| S | j jdkrt	| 
|	|
S ddlm} |
|	|
S d	S )
z2
        See NDFrame.interpolate.__doc__.
        r   r   TZf8z)interpolate is not implemented for dtype=r   )r{   r   r'  ry   limit_directionrz   rP   rG   N)r_   r   rM   r[   rN   r   ro   r	   Zinterpolate_2d_inplacerl   rX   r   rH   )rd   r{   r   r'  ry   rV  rz   r[   r   r   rP   rH   rV   rV   rW   interpolate  s@    

	zBaseMaskedArray.interpolate)r4  )r(  r4  rQ   c                K  s<   | j }| j}tt|}|||fd|i|\}}| ||S )Nr4  )rM   rN   r   r4   rX   )rd   r(  r4  r   r   rP   r   rV   rV   rW   _accumulate  s
    
zBaseMaskedArray._accumulateznpt.NDArray[np.intp])howhas_dropped_narE  ngroupsidsc                K  s   ddl m} ||}||||d}	| j}
|	jdkr>|
 }ntj|td}|dkrn|	ddv rnd	|d d < |	j
| jf||||
|d
|}|	jdkr|	j	|	jd}t||dfj}|	jdv r|S | ||S d S )Nr   )WrappedCythonOp)rY  r   rZ  Z	aggregateri   ZrankZ	na_option)topbottomF)rE  r[  Zcomp_idsrP   result_maskZohlcr   )ZidxminZidxmax)Zpandas.core.groupby.opsr]  Zget_kind_from_howrN   r   r[   r]   r   rY   r   Z_cython_op_ndim_compatrM   rY  Z_cython_arityZtiler   r   )rd   rY  rZ  rE  r[  r\  r   r]  r   r   rP   r`  Z
res_valuesZarityrV   rV   rW   _groupby_op!  s4    






zBaseMaskedArray._groupby_op)F)F)NNNT)r   )r   ).).).)T)NN)N)r   )r   )r  N)T)T)T)N)[r   
__module____qualname____doc____annotations__r   rU  rS  classmethodrX   re   rh   r   r9   rp   rs   propertyr_   r   rw   r   r   rg   r   r   r   r   r   rb   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Z__array_priority__r   r   r   r   r   r   Z_logical_methodr  r   r)   r   r  r
  r  r3   r0   r[   r  r  r  r!  r"  r+  r,  r.  r3  r?  r@  r>  rF  r:  r9  r6  r;  r8  r7  r  rQ  r   r   rW  rX  ra  __classcell__rV   rV   r   rW   rJ   k   s  
,!#]
.	M](/
	$ $(	-


QR5rJ   zSequence[BaseMaskedArray]zlist[BaseMaskedArray])masked_arraysrQ   c           
      C  s   t | } | d j}dd | D }tj|dtjt| t| d fd|jdd}dd | D }tj|dtj|tdd}|	 }g }t
|jd	 D ]2}||d
d
|f |d
d
|f d}	||	 q|S )zTranspose masked arrays in a list, but faster.

    Input should be a list of 1-dim masked arrays of equal length and all have the
    same dtype. The caller is responsible for ensuring validity of input data.
    r   c                 S  s   g | ]}|j d dqS r   r   )rM   r   r   r  rV   rV   rW   r   \  r   z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>F)orderr_   )r   r   c                 S  s   g | ]}|j d dqS rj  )rN   r   rk  rV   rV   rW   r   g  r   ri   r   Nr   )listr_   r]   r	  rk   r   r   Z
empty_likerY   r   r   rb   r   )
ri  r_   rO   Ztransposed_valuesZmasksZtransposed_masksZarr_typeZtransposed_arraysr   Ztransposed_arrrV   rV   rW   #transpose_homogeneous_masked_arraysQ  s,    

$ro  )j
__future__r   typingr   r   r   r   r   r   numpyr]   Zpandas._libsr   r	   r   Zpandas._libs.tslibsr
   Zpandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   Zpandas.compatr   r   Zpandas.errorsr   Zpandas.util._decoratorsr   Zpandas.util._validatorsr   Zpandas.core.dtypes.baser   Zpandas.core.dtypes.commonr    r!   r"   r#   r$   r%   Zpandas.core.dtypes.dtypesr&   Zpandas.core.dtypes.missingr'   r(   r)   r*   Zpandas.corer+   r  r,   r-   r.   Zpandas.core.algorithmsr/   r0   r1   r2   r3   Zpandas.core.array_algosr4   r5   Z pandas.core.array_algos.quantiler6   Zpandas.core.arrayliker7   Zpandas.core.arrays._utilsr8   Zpandas.core.arrays.baser9   Zpandas.core.constructionr:   r   r;   r<   Zpandas.core.indexersr=   Zpandas.core.opsr>   Zpandas.core.util.hashingr?   collections.abcr@   rA   r)  rB   r   rD   rE   rF   rH   Zpandas.compat.numpyrI   r   rJ   ro  rV   rV   rV   rW   <module>   sZ   @            q