o
    ŀgR                     @  s>  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'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                      sV  e Zd ZU dZded< ded< ded< eZeZed
ddZ		ddddZ
eddddddZeeejdddZddd d!Zedd#d$Zedd(d)Zedd+d)Zdd.d)Zddd/d0dd7d8Zeej	/ddd9d:Zedd;dd>d?Zd@dA ZddBdCZd fdDdEZddGdHZddJdKZeddLdMZeddNdOZddPdQZdddUdVZddWdXZ ddYdZZ!edd[d\Z"dd d^d_Z#dd`daZ$ddbdcZ%ddddeZ&ddfdgZ'd!dhdiZ(dde)j*fd"dmdnZ+eej,dodp Z,ed#d$dsdtZ-ed#d%dvdtZ-ed#d&dydtZ-d'd&dzdtZ-d{Z.	d(d)d~dZ/ded< d*ddZ0d+ddZ1edddZ2d,ddZ3dd Z4e4Z5d-ddZ6d.ddZ7d!ddZ8edd Z9edddZ:e	Rdd/ddZ;d0ddZ<dddRdd1ddZ=d2ddZ>dddZ?eej@	d3d4ddZ@dddZAeejB		d5d6ddZBeejC	/d'd7ddńZCeejDd!ddǄZDd'd8dd˄ZEd'd9dd̈́ZFeejGdddτZGd:ddԄZHd/dd՜d;ddڄZId<dd܄ZJddބ ZKd<ddZLd/dRdRdd=ddZMd/dRdRdd=ddZNd/dRdd>ddZOd/dRddd?ddZPd/dRddd?ddZQd/dRdd>ddZRd/dRdd>ddZSd+ddZTd/dRdd>ddZUd/dRdd>ddZVd@ddZWd/d dAddZXdBdd	ZY  ZZS (C  BaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   _internal_fill_value
np.ndarray_datanpt.NDArray[np.bool_]_maskvaluesmaskreturnr   c                 C  s   t | }||_||_|S N)rJ   __new__rM   rO   )clsrP   rQ   result rW   M/var/www/html/myenv/lib/python3.10/site-packages/pandas/core/arrays/masked.py_simple_new|   s   
zBaseMaskedArray._simple_newFcopyboolNonec                 C  sX   t |tjr|jtjkstd|j|jkrtd|r$| }| }|| _	|| _
d S )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)
isinstancenpndarraydtypebool_	TypeErrorshape
ValueErrorrZ   rM   rO   )selfrP   rQ   rZ   rW   rW   rX   __init__   s   
zBaseMaskedArray.__init__Nr`   rZ   c                C  s   | j |||d\}}| ||S )Nrg   )_coerce_to_array)rU   scalarsr`   rZ   rP   rQ   rW   rW   rX   _from_sequence   s   
zBaseMaskedArray._from_sequencerc   r   r`   r   c                 C  s\   t j||jd}|| j t j|td}| ||}t|| r$||jkr,t	d| d|S )Nr`   z5Default 'empty' implementation is invalid for dtype='')
r^   emptytypefillrK   onesr[   r]   r`   NotImplementedError)rU   rc   r`   rP   rQ   rV   rW   rW   rX   _empty   s   

zBaseMaskedArray._emptyboxedCallable[[Any], str | None]c                 C  s   t S rS   )str)re   rs   rW   rW   rX   
_formatter      zBaseMaskedArray._formatterr&   c                 C     t | rS   r   re   rW   rW   rX   r`         zBaseMaskedArray.dtypeitemr   r   c                 C     d S rS   rW   re   r{   rW   rW   rX   __getitem__   rw   zBaseMaskedArray.__getitem__r   c                 C  r|   rS   rW   r}   rW   rW   rX   r~      rw   r   
Self | Anyc                 C  sD   t | |}| j| }t|r|r| jjS | j| S | | j| |S rS   )r=   rO   r    r`   na_valuerM   rY   )re   r{   newmaskrW   rW   rX   r~      s   


T)limit
limit_arearZ   methodr   r   
int | Noner   #Literal['inside', 'outside'] | Nonec                C  sH  | j }| rtj|| jd}| jj}|j}|r!| }| }n|d ur)| }||||d |d ur| s|j}| }	|		 }
t
|	|	d d d 	  d }|dkrv|d |
  |d |
 O  < ||d d   ||d d  O  < n|dkr||
d |  ||
d | O  < |r| |j|jS | S |r|  }|S | }|S )Nndimr   rQ      insideoutside)rO   anyr	   get_fill_funcr   rM   TrZ   allargmaxlenrY   )re   r   r   r   rZ   rQ   funcnpvaluesnew_maskneg_maskfirstlast
new_valuesrW   rW   rX   _pad_or_backfill   s:   
&$z BaseMaskedArray._pad_or_backfillc           
      C  s   t ||\}}| j}t||t| }| rV|d urCtj|| jd}| jj	}|j	}|r4|
 }|
 }||||d | |j	|j	S |rJ| 
 }	n| d d  }	||	|< |	S |r^| 
 }	|	S | d d  }	|	S )Nr   r   )r   rO   r	   check_value_sizer   r   r   r   rM   r   rZ   rY   )
re   valuer   r   rZ   rQ   r   r   r   r   rW   rW   rX   fillna   s.   
zBaseMaskedArray.fillnarZ   r   tuple[np.ndarray, np.ndarray]c                C  rx   rS   r   )rU   rP   r`   rZ   rW   rW   rX   rh     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 )r`   kindr   r    
is_integeris_floatrb   ru   )re   r   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 )NTFrk   )r=   r#   r(   r`   rO   r   rM   rh   )re   keyr   rQ   rW   rW   rX   __setitem__3  s   





zBaseMaskedArray.__setitem__c                   sX   t |r$|| jjur$| jjjdkr$t|r$tt	| j| j
 @  S tt |S )Nr   )r)   r`   r   rM   r   r   r   r[   r^   isnanrO   r   super__contains__)re   r   	__class__rW   rX   r   D  s   zBaseMaskedArray.__contains__r@   c                 c  s~    | j dkr/| js| jD ]}|V  qd S | jj}t| j| jD ]\}}|r)|V  q|V  qd S tt| D ]}| | V  q5d S )Nr   )	r   _hasnarM   r`   r   ziprO   ranger   )re   valr   isna_irW   rW   rX   __iter__L  s   

zBaseMaskedArray.__iter__intc                 C  s
   t | jS rS   )r   rM   ry   rW   rW   rX   __len__\     
zBaseMaskedArray.__len__c                 C     | j jS rS   )rM   rc   ry   rW   rW   rX   rc   _  rz   zBaseMaskedArray.shapec                 C  r   rS   )rM   r   ry   rW   rW   rX   r   c  rz   zBaseMaskedArray.ndimc                 C  s(   | j ||}| j||}| ||S rS   )rM   swapaxesrO   rY   )re   axis1axis2datarQ   rW   rW   rX   r   g  s   zBaseMaskedArray.swapaxesr   axisr   c                 C  s0   t j| j||d}t j| j||d}| ||S Nr   )r^   deleterM   rO   rY   )re   locr   r   rQ   rW   rW   rX   r   l     zBaseMaskedArray.deletec                 O  s0   | j j|i |}| jj|i |}| ||S rS   )rM   reshaperO   rY   re   argskwargsr   rQ   rW   rW   rX   r   q  r   zBaseMaskedArray.reshapec                 O  s2   | j j|i |}| jj|i |}t| ||S rS   )rM   ravelrO   rn   r   rW   rW   rX   r   v  s   zBaseMaskedArray.ravelc                 C  s   |  | jj| jjS rS   )rY   rM   r   rO   ry   rW   rW   rX   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   nvvalidate_roundr^   roundrM   _maybe_mask_resultrO   rZ   )re   r   r   r   rP   rW   rW   rX   r     s
   zBaseMaskedArray.roundc                 C  s   |  | j | j S rS   rY   rM   rO   rZ   ry   rW   rW   rX   
__invert__     zBaseMaskedArray.__invert__c                 C  s   |  | j | j S rS   r   ry   rW   rW   rX   __neg__  r   zBaseMaskedArray.__neg__c                 C  s   |   S rS   r   ry   rW   rW   rX   __pos__  s   zBaseMaskedArray.__pos__c                 C  s   |  t| j| j S rS   )rY   absrM   rO   rZ   ry   rW   rW   rX   __abs__  s   zBaseMaskedArray.__abs__c                 C  s   t j| tdS )Nrk   )r^   asarrayobjectry   rW   rW   rX   _values_for_json  s   z BaseMaskedArray._values_for_jsonnpt.DTypeLike | Noner   r   c                 C  s   | j }t| |||\}}|du rt}|rQ|tkr)t|s)|tju r)td| dt  tj	dt
d | j|}W d   n1 sEw   Y  ||| j< |S t  tj	dt
d | jj||d}W d   |S 1 spw   Y  |S )aF  
        Convert to a NumPy Array.

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

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

        Returns
        -------
        numpy.ndarray

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

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

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

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

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

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

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

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.ignorecategoryr   )r   r8   r   r$   
libmissingNArd   warningscatch_warningsfilterwarningsRuntimeWarningrM   astyperO   )re   r`   rZ   r   hasnar   rW   rW   rX   to_numpy  s2   B





zBaseMaskedArray.to_numpyc                 C  s>   | j dkrdd | D S | jrd n| jj}| j|tjd S )Nr   c                 S  s   g | ]}|  qS rW   )tolist.0xrW   rW   rX   
<listcomp>  s    z*BaseMaskedArray.tolist.<locals>.<listcomp>r`   r   )r   r   rM   r`   r   r   r   r   )re   r`   rW   rW   rX   r     s   
zBaseMaskedArray.tolist.npt.DTypeLikec                 C  r|   rS   rW   re   r`   rZ   rW   rW   rX   r     rw   zBaseMaskedArray.astyper9   c                 C  r|   rS   rW   r   rW   rW   rX   r     rw   r   r   c                 C  r|   rS   rW   r   rW   rW   rX   r      rw   c                 C  s8  t |}|| jkr|r|  S | S t|trRt  tjdtd | j	j
|j|d}W d    n1 s5w   Y  || j	u rB| jn| j }| }|||ddS t|trc| }|j| ||dS |jdkrltj}n|jdkrwtd}ntj}|jd	v r| jrtd
|jdkr| jrtd| j|||d}|S )Nr   r   r   Frg   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)r`   r   rZ   )r%   r`   rZ   r]   r&   r   r   r   r   rM   r   numpy_dtyperO   construct_array_typer   rj   r   r^   nan
datetime64r   
no_defaultr   rd   r   )re   r`   rZ   r   rQ   rU   eaclsr   rW   rW   rX   r   $  s6   





i  NpDtype | None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
        rk   )r   r   rW   rW   rX   	__array__T  s   zBaseMaskedArray.__array__ztuple[type, ...]_HANDLED_TYPESufuncnp.ufuncru   c           	        sb  | dd}|| D ]}t|| jtf st  S q
tj| ||g|R i |}|tur.|S d|v r@tj| ||g|R i |S |dkrXtj| ||g|R i |}|turX|S t	j
t| td g }|D ]}t|trx |jO  ||j qe|| qed fddt|||i |}|jd	krtfd
d|D S |dkr| j r| jS |S |S )NoutrW   reducerk   r   rL   c                   s   ddl m}m}m} | jjdkr  }|| |S | jjdv r(  }|| |S | jjdkrC  }| jtjkr>| 	tj
} || |S tj|  < | S )Nr   )rD   rH   IntegerArrayr   r   r   )pandas.core.arraysrD   rH   r   r`   r   rZ   r^   float16r   float32r   )r   rD   rH   r   mrQ   rW   rX   reconstruct  s   



z4BaseMaskedArray.__array_ufunc__.<locals>.reconstructr   c                 3  s    | ]} |V  qd S rS   rW   r   )r  rW   rX   	<genexpr>  s    z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>)r   rL   )getr]   r   rJ   NotImplementedr,   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncr^   zerosr   r[   rO   appendrM   getattrnouttupler   	_na_value)	re   r   r   inputsr   r   r   rV   inputs2rW   )rQ   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)rQ   rn   )pyarrowr:   rM   rO   )re   rn   parW   rW   rX   __arrow_array__  s   zBaseMaskedArray.__arrow_array__c                 C  
   | j  S rS   )rO   r   ry   rW   rW   rX   r     s   
zBaseMaskedArray._hasnanpt.NDArray[np.bool_] | Nonec                 C  s^   |d u r(| j  }|tju r|dB }|S t|r&t|t|kr&|t|B }|S | j |B }|S )NT)rO   rZ   r   r   r"   r   r)   )re   rQ   otherrW   rW   rX   _propagate_mask  s   


zBaseMaskedArray._propagate_maskc           	      C  sz  |j }d }t|ds t|r t|t| kr t|}t|dd}t|tr-|j|j	}}nt|rDt|t
s;t|}|jdkrDtdt|t| f}t|}t|}|dv rdt|tjrdt|}| ||}|tju rt| j}| jjdkr|dv rtd	| d
|dv rd}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rt| jdk| j	 @ d|}|d urt|dk| @ d|}nD|tjurt|dkd|}n4|dkr7|d urt|dk| @ d|}n|tjur)t|dkd|}t| jdk| j	 @ d|}| ||S )Nr`   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   r  r  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8r[   r  r   r   )r  r"  r   )r   r  Fr   r  ) __name__hasattrr"   r   pd_arrayr<   r]   rJ   rM   rO   r9   r^   r   r   rq   r.   maybe_prepare_scalar_for_opget_array_opr;   ra   r[   r  r   r   	ones_liker`   r   r   float64errstatewherer   )	re   r  opop_nameomaskpd_oprQ   rV   r`   rW   rW   rX   _arith_method  sn   










zBaseMaskedArray._arith_methodrD   c                 C  s(  ddl m} d }t|tr|j|j}}nt|r3t|}|j	dkr't
dt| t|kr3td|tju rKtj| jjdd}tj| jjdd}n<t 0 tdd	t tdd	t t| jd
|j d
}||}|tu rxt| j||}W d    n1 sw   Y  | ||}|||ddS )Nr   rC   r   r  zLengths must match to comparer[   rk   r   elementwise__Fr   )r   rD   r]   rJ   rM   rO   r"   r^   r   r   rq   r   rd   r   r   r
  rc   rp   r   r   r   FutureWarningDeprecationWarningr  r%  r  r>   r  )re   r  r.  rD   rQ   rV   r   rW   rW   rX   _cmp_method,  s0   




zBaseMaskedArray._cmp_methodrV   *np.ndarray | tuple[np.ndarray, np.ndarray]c           	      C  s   t |tr|\}}| ||| ||fS |jjdkr(ddlm} |||ddS |jjdkr;ddlm} |||ddS t	|jdrdt
|jrddd	lm} |jd
||< t ||sb|j||jdS |S |jjdv rwddlm} |||ddS tj||< |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r   r   rG   Fr   r   rC   r  )TimedeltaArrayr   rk   r   r   )r]   r  r   r`   r   r   rH   rD   r   is_np_dtyper
   r9  rn   rY   r   r^   r   )	re   rV   rQ   divr"  rH   rD   r9  r   rW   rW   rX   r   T  s,   
	



z"BaseMaskedArray._maybe_mask_resultc                 C  r  rS   )rO   rZ   ry   rW   rW   rX   r)     r   zBaseMaskedArray.isnac                 C  r   rS   r   ry   rW   rW   rX   r    rz   zBaseMaskedArray._na_valuec                 C  s   | j j| jj S rS   )rM   nbytesrO   ry   rW   rW   rX   r=    s   zBaseMaskedArray.nbytes	to_concatSequence[Self]c                 C  s:   t jdd |D |d}t jdd |D |d}| ||S )Nc                 S     g | ]}|j qS rW   rM   r   rW   rW   rX   r         z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>r   c                 S  r@  rW   )rO   r   rW   rW   rX   r     rB  )r^   concatenate)rU   r>  r   r   rQ   rW   rW   rX   _concat_same_type  s   
z!BaseMaskedArray._concat_same_typeencodinghash_key
categorizenpt.NDArray[np.uint64]c                C  s*   t | j|||d}t| jj||  < |S )N)rE  rF  rG  )r?   rM   hashr`   r   r)   )re   rE  rF  rG  hashed_arrayrW   rW   rX   _hash_pandas_object  s
   
z#BaseMaskedArray._hash_pandas_object)
allow_fill
fill_valuer   rL  rM  Scalar | Nonec          	      C  sp   t |r| jn|}t| j||||d}t| j|d||d}|r2t|r2t|dk}|||< ||A }| ||S )N)rM  rL  r   Tr   )	r)   rK   r3   rM   rO   r*   r^   r   rY   )	re   indexerrL  rM  r   data_fill_valuerV   rQ   	fill_maskrW   rW   rX   r3     s    
zBaseMaskedArray.takec                   sr   ddl m} t|}t j|} jr)|jtko#t	 fdd|D }|| j
< tj jjtd}|||ddS )Nr   rC   c                 3  s    | ]	}| j ju V  qd S rS   r   )r   r   ry   rW   rX   r    s    
z'BaseMaskedArray.isin.<locals>.<genexpr>rk   Fr   )r   rD   r^   r   r0   rM   r   r`   r   r   rO   r
  rc   r[   )re   rP   rD   
values_arrrV   values_have_NArQ   rW   ry   rX   r0     s   

zBaseMaskedArray.isinc                 C  s    | j  }| j }| ||S rS   )rM   rZ   rO   rY   )re   r   rQ   rW   rW   rX   rZ     s   

zBaseMaskedArray.copyr   keepLiteral['first', 'last', False]c                 C  s   | j }| j}tj|||dS )N)rT  rQ   )rM   rO   algos
duplicated)re   rT  rP   rQ   rW   rW   rX   rW    s   zBaseMaskedArray.duplicatedc                 C  s    t | j| j\}}| ||S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rV  unique_with_maskrM   rO   rY   )re   uniquesrQ   rW   rW   rX   unique  s   zBaseMaskedArray.uniqueleftr   $NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterNumpySorter | Nonenpt.NDArray[np.intp] | np.intpc                 C  s4   | j rtdt|tr|t}| jj|||dS )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)r]  r_  )r   rd   r]   r9   r   r   rM   searchsorted)re   r   r]  r_  rW   rW   rX   rb    s   

zBaseMaskedArray.searchsorteduse_na_sentinel!tuple[np.ndarray, ExtensionArray]c                 C  s   | j }| j}t|d|d\}}|j| jjksJ |j| jf| }|s&|s+t|}nt|d }tj|t	d}|so|ro|
 }	|	dkrJtd}
n
|d |	  d }
|||
k  d7  < |
||dk< t||
d}d||
< | ||}||fS )NT)rc  rQ   r   rk   r   r   )rM   rO   r/   r`   r   r   r   r^   r
  r[   r   intpmaxinsertrY   )re   rc  arrrQ   codesrY  has_nasizeuniques_maskna_indexna_code
uniques_earW   rW   rX   	factorize  s(   
zBaseMaskedArray.factorizec                 C  s   | j S rS   rA  ry   rW   rW   rX   _values_for_argsort'  s   z#BaseMaskedArray._values_for_argsortdropnarB   c                 C  s   ddl m}m} ddlm} tj| j|| jd\}}}t	j
t|ft	jd}| }	|dkr2d|d< |||	}
|| j ||}||
|dd	d
S )aA  
        Returns a Series containing counts of each unique value.

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

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )IndexrB   r:  rr  rQ   rk   Tr   countF)indexnamerZ   )pandasrs  rB   pandas.arraysr   rV  value_counts_arraylikerM   rO   r^   r
  r   ra   rZ   r`   r   )re   rr  rs  rB   r   keysvalue_counts
na_counter
mask_indexrQ   rh  rv  rW   rW   rX   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 )Nrt  rk   )	r2   rM   rO   r^   r
  rc   ra   rn   argsort)re   rr  rV   res_maskrW   rW   rX   _modeS  s   zBaseMaskedArray._modec                 C  sd   t | t |kr
dS |j| jkrdS t| j|jsdS | j| j  }|j|j  }t||dddS )NFT)
strict_nandtype_equal)rn   r`   r^   array_equalrO   rM   r'   )re   r  r[  rightrW   rW   rX   equals\  s   zBaseMaskedArray.equalsqsnpt.NDArray[np.float64]interpolationc                 C  s   t | j| jtj||d}| jr=| jdkrt|  	 r4tj
|jtd}t| jr3tj|j| jjd}ntj|jtd}ntj|jtd}| j||dS )z
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rQ   rM  r  r     rk   r  )r6   rM   rO   r^   r   r   r   rq   r)   r   rp   rc   r[   r!   r`   r
  r   r   )re   r  r  resout_maskrW   rW   rX   	_quantilel  s$   


zBaseMaskedArray._quantile)skipnakeepdimsrw  r  r  c          
      K  s   |dv rt | |dd|i|}n | j}| j}t td| }|dd }	||f|	||d|}|rQt|r?| j|dddS |d	}tj	d	t
d
}| ||S t|rXtjS |S )N>	   r   r   rf  minstdsumvarmeanprodr  r   r   )r   r  rQ   r   )r   )rw  r   	mask_sizer   rk   rW   )r  rM   rO   r-   popr)   _wrap_na_resultr   r^   r
  r[   r   r   r   )
re   rw  r  r  r   rV   r   rQ   r.  r   rW   rW   rX   _reduce  s    
zBaseMaskedArray._reducec                C  s>   t |tjr|r| jj|d}n| jj|d}| ||S |S r   )r]   r^   r_   rO   r   r   r   )re   rw  rV   r  r   rQ   rW   rW   rX   _wrap_reduction_result  s   z&BaseMaskedArray._wrap_reduction_resultc                C  s   t j|td}| jdkrdnd}|dv r|}n-|dv s!| jjdkr'| jjj}nt p,t }|r1dnd	}|r7d
nd}	|||	|d| jj	 }t j
dg|d}
| j|
|dS )Nrk   Float32r   r+  )r  medianr  r  skewkurt)r  rf     int32int64uint32uint64)r   r   ur   r   r  )r^   rp   r[   r`   itemsizer   rw  r   r   r   r:   r   )re   rw  r   r  rQ   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   rW   rW   rX   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   rk   r  r   )r]   r^   r_   r   r
  rc   r[   r  )re   rw  rV   r  	min_countr   rW   rW   rX    _wrap_min_count_reduction_result  s   z0BaseMaskedArray._wrap_min_count_reduction_resultr  r  r   r  AxisInt | Nonec                K  8   t d| tj| j| j|||d}| jd||||dS )NrW   r  r  )r   validate_sumr5   r  rM   rO   r  re   r  r  r   r   rV   rW   rW   rX   r       
zBaseMaskedArray.sumc                K  r  )NrW   r  r  )r   validate_prodr5   r  rM   rO   r  r  rW   rW   rX   r    r  zBaseMaskedArray.prodr  c                K  4   t d| tj| j| j||d}| jd|||dS )NrW   r  r  )r   validate_meanr5   r  rM   rO   r  re   r  r   r   rV   rW   rW   rX   r       zBaseMaskedArray.meanr   r  r   ddofr  c                K  :   t jd|dd tj| j| j|||d}| jd|||dS )NrW   r  fnamer  r  )r   validate_stat_ddof_funcr5   r  rM   rO   r  re   r  r   r  r   rV   rW   rW   rX   r       zBaseMaskedArray.varc                K  r  )NrW   r  r  r  r  )r   r  r5   r  rM   rO   r  r  rW   rW   rX   r    r  zBaseMaskedArray.stdc                K  r  )NrW   r  r  )r   validate_minr5   r  rM   rO   r  r  rW   rW   rX   r  %  r  zBaseMaskedArray.minc                K  r  )NrW   r  rf  )r   validate_maxr5   rf  rM   rO   r  r  rW   rW   rX   rf  /  r  zBaseMaskedArray.maxc                 C  s   t |  ||dS )N)	na_action)r1   r   )re   mapperr  rW   rW   rX   map9  s   zBaseMaskedArray.mapc                K  s^   t d| | j }t|| j| j | }|r|S |s)t	| dks)| j s+|S | j
jS )aY  
        Return whether any element is truthy.

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

        .. versionchanged:: 1.4.0

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

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

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

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

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

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

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        rW   r   )r   validate_anyrM   rZ   r^   putmaskrO   _falsey_valuer   r   r`   r   re   r  r   r   rP   rV   rW   rW   rX   r   <  s   ?
zBaseMaskedArray.anyc                K  sb   t d| | j }t|| j| j |j|d}|r|S |r+t	| dks+| j
 s-|S | jjS )aL  
        Return whether all elements are truthy.

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

        .. versionchanged:: 1.4.0

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

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

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

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

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

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

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        rW   r   r   )r   validate_allrM   rZ   r^   r  rO   _truthy_valuer   r   r   r`   r   r  rW   rW   rX   r     s   ?
zBaseMaskedArray.allr   rH   c             
   K  s   | j jdkr|r| j }	| j }
n#| j}	| j}
n| j jdv r.d}| jd}	| j }
ntd| j  tj|	f|d|||||
d| |sK| S | j jdkrYt	| 
|	|
S ddlm} |
|	|
S )	z2
        See NDFrame.interpolate.__doc__.
        r   r   Tf8z)interpolate is not implemented for dtype=r   )r   r   rv  r   limit_directionr   rQ   rG   )r`   r   rM   rZ   rO   r   rq   r	   interpolate_2d_inplacern   rY   r   rH   )re   r   r   rv  r   r  r   rZ   r   r   rQ   rH   rW   rW   rX   interpolate  s@   

	zBaseMaskedArray.interpolate)r  c                K  s<   | j }| j}tt|}|||fd|i|\}}| ||S )Nr  )rM   rO   r  r4   rY   )re   rw  r  r   r   rQ   r.  rW   rW   rX   _accumulate  s
   
zBaseMaskedArray._accumulatehowhas_dropped_nangroupsidsnpt.NDArray[np.intp]c                K  s   ddl m} ||}||||d}	| j}
|	jdkr|
 }ntj|td}|dkr7|	ddv r7d	|d d < |	j
| jf||||
|d
|}|	jdkr]|	j	|	jd}t||dfj}|	jdv rd|S | ||S )Nr   )WrappedCythonOp)r  r   r  	aggregaterk   rank	na_option)topbottomF)r  r  comp_idsrQ   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsr  get_kind_from_howrO   r   rZ   r^   r
  r[   r  _cython_op_ndim_compatrM   r  _cython_aritytiler   r   )re   r  r  r  r  r  r   r  r   r.  rQ   r  
res_valuesarityrW   rW   rX   _groupby_op!  s4   






zBaseMaskedArray._groupby_op)rP   rL   rQ   rN   rR   r   )F)rP   rL   rQ   rN   rZ   r[   rR   r\   )rZ   r[   rR   r   )rc   r   r`   r   )rs   r[   rR   rt   )rR   r&   )r{   r   rR   r   )r{   r   rR   r   )r{   r   rR   r   )
r   r   r   r   r   r   rZ   r[   rR   r   )NNNT)r   r   rZ   r[   rR   r   )r`   r   rZ   r[   rR   r   )rR   r\   )rR   r[   )rR   r@   )rR   r   )rR   r   )rR   r   )r   )r   r   rR   r   )r   r   )rR   rL   )r`   r   rZ   r[   r   r   rR   rL   ).)r`   r   rZ   r[   rR   rL   )r`   r   rZ   r[   rR   r9   )r`   r   rZ   r[   rR   r   )T)NN)r`   r   rZ   r   rR   rL   )r   r   r   ru   rS   )rQ   r  rR   rN   )rR   rD   )rV   r8  rQ   rL   )r>  r?  r   r   rR   r   )rE  ru   rF  ru   rG  r[   rR   rH  )rL  r[   rM  rN  r   r   rR   r   )rP   r   rR   rD   )r   )rT  rU  rR   rN   )r[  N)r   r\  r]  r^  r_  r`  rR   ra  )rc  r[   rR   rd  )rr  r[   rR   rB   )rr  r[   rR   r   )r  r  r  ru   rR   rJ   )rw  ru   r  r[   r  r[   )rw  ru   )r  r[   r  r   r   r  )r  r[   r   r  )r  r[   r   r  r  r   )r   r   r   r   rZ   r[   rR   rH   )rw  ru   r  r[   rR   rJ   )
r  ru   r  r[   r  r   r  r   r  r  )[r%  
__module____qualname____doc____annotations__r   r  r  classmethodrY   rf   rj   r   r9   rr   rv   propertyr`   r   r~   r   r   rh   r   r   r   r   r   rc   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   __array_priority__r   r  r  r   r  r2  _logical_methodr7  r   r)   r  r=  rD  rK  r3   r0   rZ   rW  rZ  rb  rp  rq  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  rf  r  r   r   r  r  r  __classcell__rW   rW   r   rX   rJ   k   s  
 ,!#]
.	M](/
	$$(	-


QR5rJ   masked_arraysSequence[BaseMaskedArray]rR   list[BaseMaskedArray]c           
      C  s   t | } | d j}dd | D }tj|dtjt| t| d fd|jdd}dd | D }tj|dtj|tdd}|	 }g }t
|jd	 D ]}||d
d
|f |d
d
|f d}	||	 qH|S )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     g | ]	}|j d dqS r   r   )rM   r   r   rh  rW   rW   rX   r   \      z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>F)orderr`   )r   r   c                 S  r  r  )rO   r   r  rW   rW   rX   r   g  r  rk   r   Nr  )listr`   r^   rC  rm   r   r   
empty_liker[   r   r   rc   r  )
r  r`   rP   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrrW   rW   rX   #transpose_homogeneous_masked_arraysQ  s,   

$r  )r  r  rR   r  )j
__future__r   typingr   r   r   r   r   r   numpyr^   pandas._libsr   r	   r   pandas._libs.tslibsr
   pandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.compatr   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._validatorsr   pandas.core.dtypes.baser   pandas.core.dtypes.commonr    r!   r"   r#   r$   r%   pandas.core.dtypes.dtypesr&   pandas.core.dtypes.missingr'   r(   r)   r*   pandas.corer+   rV  r,   r-   r.   pandas.core.algorithmsr/   r0   r1   r2   r3   pandas.core.array_algosr4   r5    pandas.core.array_algos.quantiler6   pandas.core.arrayliker7   pandas.core.arrays._utilsr8   pandas.core.arrays.baser9   pandas.core.constructionr:   r'  r;   r<   pandas.core.indexersr=   pandas.core.opsr>   pandas.core.util.hashingr?   collections.abcr@   rA   rx  rB   r   rD   rE   rF   rH   pandas.compat.numpyrI   r   rJ   r  rW   rW   rW   rX   <module>   s\    @            q