
    `VgQ                       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rd dlRmSZS d dlJmTZT d dlmUZUmVZV d dlWmXZY  edd      ZZ G d deIeK      Z[y)     )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                     e Zd ZU dZded<   ded<   ded<   eZeZ	 dP	 	 	 	 	 	 	 dQd	Ze	d
dd	 	 	 	 	 dRd       Z
edSd       ZedTd       ZedUd       Z	 	 	 	 	 	 dVdZ eej"                        	 dW	 	 	 dXd       Ze	dd	 	 	 	 	 dYd       Zd ZdZdZd Zd[dZed\d       Zed[d       ZdXdZd]d^dZdXdZdXdZedXd       Zd]d_d ZdXd!ZdXd"Z dXd#Z!dXd$Z"d
de#jH                  f	 	 	 	 	 	 	 d`d%Z%edadbd&       Z&edadcd'       Z&edaddd(       Z&deddd*Z&d+Z'dfdgd,Z(d-ed.<   dhd/Z)dfd0Z*edid1       Z+	 	 	 	 djd2Z,d3 Z-e-Z.dkd4Z/d5 Z0dld6Z1ed7        Z2ed[d8       Z3e		 d]	 	 	 	 	 	 	 dmd9       Z4dd
dd:	 	 	 	 	 	 	 	 	 dnd;Z5dkd<Z6dXd=Z7dXd>Z8 eejr                        	 	 do	 	 	 	 	 	 	 dpd?       Z9 eejt                        e#jH                  e#jH                  f	 	 	 	 	 dqd@       Z: eejv                        dldA       Z;dedrdBZ< eejz                        didC       Z=	 	 	 	 	 	 dsdDZ>d)dEdtdFZ?dudGZ@d)dddHdvdIZAd)dddHdvdJZBd)ddKdvdLZCd)ddKdvdMZDd)dEdwdNZEd)dEdwdOZFy
)xrB   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_]_maskFc                0   t        |t        j                        r|j                  t        j                  k(  st        d      |j                  |j                  k7  rt        d      |r |j                         }|j                         }|| _	        || _
        y )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
ValueErrorcopyrG   rI   )selfvaluesmaskrS   s       Z/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/arrays/masked.py__init__zBaseMaskedArray.__init__m   sx     4,rxx1G2  <<4::%ABB[[]F99;D

    NrN   rS   c               B    | j                  |||      \  }} | ||      S )NrZ   )_coerce_to_array)clsscalarsrN   rS   rU   rV   s         rW   _from_sequencezBaseMaskedArray._from_sequence   s,     ++G5t+L64  rY   c                    t        |       Nr   rT   s    rW   rN   zBaseMaskedArray.dtype   s    !$''rY   c                     y ra    rT   items     rW   __getitem__zBaseMaskedArray.__getitem__       rY   c                     y ra   rd   re   s     rW   rg   zBaseMaskedArray.__getitem__   rh   rY   c                    t        | |      }| j                  |   }t        |      r'|r| j                  j                  S | j
                  |   S  t        |       | j
                  |   |      S ra   )r9   rI   r   rN   na_valuerG   type)rT   rf   newmasks      rW   rg   zBaseMaskedArray.__getitem__   sd     #4.**T"7zz***::d##tDz$**T*G44rY   c                b   t        ||      \  }}| j                  }t        |      r?t        |      t        |       k7  r#t	        dt        |       dt        |              ||   }|j                         r|t        j                  || j                        }| j                  j                         j                  }|j                         j                  } ||||        t        |       |j                  |j                        S | j                         }|||<   |S | j                         }|S )Nz'Length of 'value' does not match. Got (z)  expected )ndim)limitrV   )r   rI   r(   lenrR   anyr   get_fill_funcro   rG   rS   Trl   )	rT   valuemethodrp   rV   funcnpvaluesnew_mask
new_valuess	            rW   fillnazBaseMaskedArray.fillna   s    /uf=vzz5zSY& =c%j\ J!!$T-  $KE88:!,,V$))D::??,..99;==XU:!tDz(**hjj99 "YY[
#(
4   JrY   rS   c                   t        |       ra   r   )r]   rU   rN   rS   s       rW   r\   z BaseMaskedArray._coerce_to_array   s     "#&&rY   c                   | j                   j                  }|dk(  rt        j                  |      ro|S |dk(  r,t        j                  |      st        j
                  |      r>|S t        j                  |      s%t        j
                  |      r|j	                         r|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 )rN   kindr
   r   
is_integeris_floatrP   str)rT   ru   r   s      rW   _validate_setitem_valuez'BaseMaskedArray._validate_setitem_value   s     zz3;{{5!S[~~e$U(; ~~e$e)<AQAQAS
 /#e*\$**NOOrY   c                Z   t        | |      }t        |      rVt        || j                        rd| j                  |<   y | j                  |      }|| j                  |<   d| j                  |<   y | j                  || j                        \  }}|| j                  |<   || j                  |<   y )NTFrN   )r9   r$   r*   rN   rI   r   rG   r\   )rT   keyru   rV   s       rW   __setitem__zBaseMaskedArray.__setitem__   s    !$,U$UDJJ7"&

3
  44U;"'

3"'

3++E+Dt

3

3rY   c              #    K   | j                   dk(  rSt        t        |             D ];  }| j                  |   r| j                  j
                   +| j                  |    = y t        t        |             D ]	  }| |     y w)N   )ro   rangerq   rI   rN   rk   rG   )rT   is     rW   __iter__zBaseMaskedArray.__iter__   su     99>3t9% (::a=**---**Q-'	( 3t9% 1gs   BBc                ,    t        | j                        S ra   )rq   rG   rb   s    rW   __len__zBaseMaskedArray.__len__   s    4::rY   c                .    | j                   j                  S ra   )rG   rQ   rb   s    rW   rQ   zBaseMaskedArray.shape   s    zzrY   c                .    | j                   j                  S ra   )rG   ro   rb   s    rW   ro   zBaseMaskedArray.ndim  s    zzrY   c                    | j                   j                  ||      }| j                  j                  ||      } t        |       ||      S ra   )rG   swapaxesrI   rl   )rT   axis1axis2datarV   s        rW   r   zBaseMaskedArray.swapaxes  sA    zz""5%0zz""5%0tDz$%%rY   r   c                    t        j                  | j                  ||      }t        j                  | j                  ||      } t	        |       ||      S Naxis)rL   deleterG   rI   rl   )rT   locr   r   rV   s        rW   r   zBaseMaskedArray.delete  sA    yySt4yySt4tDz$%%rY   c                     | j                   j                  |i |} | j                  j                  |i |} t        |       ||      S ra   )rG   reshaperI   rl   rT   argskwargsr   rV   s        rW   r   zBaseMaskedArray.reshape  sK    !tzz!!4262!tzz!!4262tDz$%%rY   c                     | j                   j                  |i |} | j                  j                  |i |} t        |       ||      S ra   )rG   ravelrI   rl   r   s        rW   r   zBaseMaskedArray.ravel  sK    tzz00tzz00tDz$%%rY   c                v     t        |       | j                  j                  | j                  j                        S ra   )rl   rG   rt   rI   rb   s    rW   rt   zBaseMaskedArray.T  s%    tDz$**,,

55rY   c                    t        j                  ||       t        j                  | j                  fd|i|}| j                  || j                  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.
        decimals)nvvalidate_roundrL   roundrG   _maybe_mask_resultrI   rS   )rT   r   r   r   rU   s        rW   r   zBaseMaskedArray.round!  sP    0 	$'$**BxB6B &&vtzz/@AArY   c                l     t        |       | j                   | j                  j                               S ra   rl   rG   rI   rS   rb   s    rW   
__invert__zBaseMaskedArray.__invert__B  &    tDz4::+tzz'899rY   c                l     t        |       | j                   | j                  j                               S ra   r   rb   s    rW   __neg__zBaseMaskedArray.__neg__E  r   rY   c                "    | j                         S ra   r|   rb   s    rW   __pos__zBaseMaskedArray.__pos__H  s    yy{rY   c                |     t        |       t        | j                        | j                  j	                               S ra   )rl   absrG   rI   rS   rb   s    rW   __abs__zBaseMaskedArray.__abs__K  s(    tDz#djj/4::??+<==rY   c                r   |t         j                  u rt        j                  }|t        }| j
                  rct        |      s,t        |      s!|t        j                  u rt        d| d      | j                  j                  |      }||| j                  <   |S | j                  j                  ||      }|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])
        zcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.r|   )r
   
no_default
libmissingNAobject_hasnar#   r%   rR   rG   astyperI   )rT   rN   rS   rk   r   s        rW   to_numpyzBaseMaskedArray.to_numpyP  s    D s~~%!}}H=E;;#E*'.
- )% 1& &  ::$$U+D'D  ::$$U$6DrY   c                     y ra   rd   rT   rN   rS   s      rW   r   zBaseMaskedArray.astype  rh   rY   c                     y ra   rd   r   s      rW   r   zBaseMaskedArray.astype  rh   rY   c                     y ra   rd   r   s      rW   r   zBaseMaskedArray.astype  rh   rY   Tc                |   t        |      }t        || j                        r|r| j                         S | S t	        |t
              rv| j                  j                  |j                  |      }|| j                  u r| j                  n| j                  j                         }|j                         } |||d      S t	        |t              r$|j                         }|j                  | ||      S t        |      rt        j                  }n1t!        |      rt        j"                  d      }nt$        j&                  }t)        |      r| j*                  rt-        d      t/        |      r| j*                  rt-        d      | j1                  |||      }| j                  j2                  dk(  rt5        ||d      S |S )	Nr|   FrZ   NaTzcannot convert NA to integerz cannot convert float NaN to bool)rN   rk   rS   r   )r&   r   rN   rS   rK   r'   rG   r   numpy_dtyperI   construct_array_typer   r_   r    rL   nanr   
datetime64r
   r   r!   r   rR   r   r   r   r   )rT   rN   rS   r   rV   r]   eaclsrk   s           rW   r   zBaseMaskedArray.astype  sk   U#%,yy{"K e_-::$$U%6%6T$BD "&!34::9JD,,.CtT..e^,..0E''E'EE
 % vvH '}}U+H~~H E"t{{;<<DKK?@@}}58$}G::??c! "$E::rY   i  c                &    | j                  |      S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        r   )r   )rT   rN   s     rW   	__array__zBaseMaskedArray.__array__  s    
 }}5}))rY   ztuple[type, ...]_HANDLED_TYPESc                6  	
 |j                  dd      }||z   D ](  }t        || j                  t        fz         r"t        c S  t        j                  | ||g|i |}|t        ur|S d|v rt        j                  | ||g|i |S |dk(  r%t        j                  | ||g|i |}|t        ur|S t        j                  t        |       t              	g }|D ]N  }t        |t              r+	|j                  z  	|j                  |j                          >|j                  |       P 	fd
 t#        ||      |i |}|j$                  dkD  rt'        
fd|D              S |dk(  r(| j                  j)                         r| j*                  S |S  
|      S )Noutrd   reducer   c                   ddl m}m}m} t	        | j
                        rj                         } || |      S t        | j
                        rj                         } || |      S t        | j
                        rUj                         }| j
                  t        j                  k(  r| j                  t        j                        }  || |      S t        j                  | <   | S )Nr   )r=   FloatingArrayIntegerArray)pandas.core.arraysr=   r   r   r   rN   rS   r!   r    rL   float16r   float32r   )xr=   r   r   mrV   s        rW   reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s      QWW%IIK#Aq))!!''*IIK#Aq))(IIK77bjj( ,A$Q**&&$HrY   r   c              3  .   K   | ]  } |        y wra   rd   ).0r   r   s     rW   	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>2  s     8AQ8s   )getrK   r   rB   NotImplementedr0   !maybe_dispatch_ufunc_to_dunder_opr.   dispatch_ufunc_with_outdispatch_reduction_ufuncrL   zerosrq   boolrI   appendrG   getattrnouttuplerr   	_na_value)rT   ufuncrv   inputsr   r   r   resultinputs2rV   r   s            @@rW   __array_ufunc__zBaseMaskedArray.__array_ufunc__  s    jj## 	&Aa!4!47I!IJ%%	&
 66%
"(
,2
 'MF?44eV&,06  X77eV&,06F ^+xxD	. 	"A!_-qww'q!	"	4 (';F;::>8888xzz~~~~%Mv&&rY   c                Z    ddl }|j                  | j                  | j                  |      S )z6
        Convert myself into a pyarrow Array.
        r   N)rV   rl   )pyarrowarrayrG   rI   )rT   rl   pas      rW   __arrow_array__zBaseMaskedArray.__arrow_array__;  s$     	xx

$x??rY   c                6    | j                   j                         S ra   )rI   rr   rb   s    rW   r   zBaseMaskedArray._hasnaC  s     zz~~rY   c                    |3| j                   j                         }|t        j                  u r|dz  }|S | j                   |z  }|S )NT)rI   rS   r   r   )rT   rV   others      rW   _propagate_maskzBaseMaskedArray._propagate_maskL  sJ     <::??$D
%d{  ::$DrY   c                T   |j                   }d }t        |t              r|j                  |j                  }}nJt        |      r?t        |t              st        j                  |      }|j                  dkD  rt        d      t        j                  |t        |       f      }t        j                  |      }t        |      }|dv r%t        |t        j                         rt#        |      }| j%                  ||      }|t&        j(                  u rt        j*                  | j                        }| j,                  j.                  dk(  r.|dv rt        d| d      |dv rd	}nd
}|j1                  |      }nd|v r| j,                  j.                  dk7  rp|j1                  t        j2                        }nP| j,                  j.                  dv r|dv r|}t        j4                  d      5   || j                  |      }d d d        |dk(  rt        j6                  | j                  dk(  | j                   z  d|      }|t        j6                  |dk(  | z  d|      }n|t&        j(                  urt        j6                  |dk(  d|      }n|dk(  r|t        j6                  |dk(  | z  d|      }n,|t&        j(                  urt        j6                  |dk(  d|      }t        j6                  | j                  dk(  | j                   z  d|      }| j9                  |      S # 1 sw Y   %xY w)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int8r   r   r   )r   u)r   r   ignoreallr   Fr   r   )__name__rK   rB   rG   rI   r"   r7   rL   asarrayro   NotImplementedErrorr0   maybe_prepare_scalar_for_oprq   get_array_opr8   rO   r   r   r   r   	ones_likerN   r   r   float64errstatewherer   )	rT   r   opop_nameomaskpd_oprV   r   rN   s	            rW   _arith_methodzBaseMaskedArray._arith_methodX  s   ++e_- ;;5E% e^4

5)zzA~)*TUU //D	|D  $.u5o%*UBHH*E KE##E51JMM!\\$**-Fzz#%   .$WI-NO  /"E"Eu-g%$**//S*@  rzz2 zz*,<O1O * 2tzz512 e88TZZ1_;UDID xx!v 5udCjmm+xx
E48 xx!v 5udCjmm+xx
E4888TZZ1_;UDID&&vt44+2 2s   &LL'c                   ddl m} d }t        |t              r|j                  |j
                  }}n\t        |      rQt        j                  |      }|j                  dkD  rt        d      t        |       t        |      k7  rt        d      |t        j                  u rWt        j                  | j                  j                   d      }t        j"                  | j                  j                   d      }nt%        j&                         5  t%        j(                  dd	t*               t        j,                  d
      5  t/        | j                  d|j0                   d      } ||      }d d d        t2        u rt5        | j                  ||      }d d d        | j7                  ||      } ||d      S # 1 sw Y   MxY w# 1 sw Y   2xY w)Nr   r<   r   r   zLengths must match to comparer   r   r  elementwiser  __Fr|   )r   r=   rK   rB   rG   rI   r"   rL   r  ro   r  rq   rR   r   r   r   rQ   oneswarningscatch_warningsfilterwarningsFutureWarningr  r   r  r   r:   r   )rT   r   r  r=   rV   r   rv   s          rW   _cmp_methodzBaseMaskedArray._cmp_method  so   3e_-++u{{4E% JJu%EzzA~)*TUU4yCJ& !@AAJMM!
 XXdjj..f=F774::++6:D((* G ''-O[[X. +$TZZ2bkk]"1EFF#E]F+ ^+/

E2FFG ##D%0FDu55+ +G Gs$   2G=-F6*'G6F?	;GGc                &   t        |t              r)|\  }}| j                  ||      | j                  ||      fS t        |j                        rddlm}  |||d      S t        |j                        rddlm}  |||d      S |j                  dk(  rCddlm	} t        ||      s|j                  |      }|j                  j                  d      ||<   |S t        |j                        rdd	lm}  |||d      S t        j                  ||<   |S )
z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r   )r   Fr|   r<   ztimedelta64[ns])TimedeltaArrayr   r   )rK   r   r   r    rN   r   r   r   r=   r  _simple_newrl   r!   r   rL   r   )	rT   r   rV   divr   r   r=   r  r   s	            rW   r   z"BaseMaskedArray._maybe_mask_result  s     fe$HC''T2''T2 
 &,,'8 E::6<<(7599\\..9fn5'33F;!<<,,U3F4LMfll+7599 66F4LMrY   c                6    | j                   j                         S ra   )rI   rS   rb   s    rW   r+   zBaseMaskedArray.isna  s    zz  rY   c                .    | j                   j                  S ra   rN   rk   rb   s    rW   r   zBaseMaskedArray._na_value  s    zz"""rY   c                \    | j                   j                  | j                  j                  z   S ra   )rG   nbytesrI   rb   s    rW   r%  zBaseMaskedArray.nbytes	  s!    zz  4::#4#444rY   c                    t        j                  |D cg c]  }|j                   c}|      }t        j                  |D cg c]  }|j                   c}|      } | ||      S c c}w c c}w r   )rL   concatenaterG   rI   )r]   	to_concatr   r   r   rV   s         rW   _concat_same_typez!BaseMaskedArray._concat_same_type  sV     ~~	:1qww:F~~	:1qww:F4 ;:s   A(A-)
allow_fill
fill_valuer   c               "   t        |      r| j                  n|}t        | j                  ||||      }t        | j                  |d||      }|r-t        |      r"t        j                  |      dk(  }|||<   ||z  } t        |       ||d      S )N)r+  r*  r   TFr|   )	r+   rE   r3   rG   rI   r,   rL   r  rl   )	rT   indexerr*  r+  r   data_fill_valuer   rV   	fill_masks	            rW   r3   zBaseMaskedArray.take  s     8<J7G$33ZJJ&!
 JJDZd
 %
+

7+r1I *F9)#DtDz&$U33rY   c                f    ddl m} t        j                  |      }t	         j
                  |      } j                  r:t        |j                        xr t         fd|D              }|| j                  <   t        j                   j
                  j                  t              } |||d      S )Nr   r<   c              3  N   K   | ]  }|j                   j                  u   y wra   r#  )r   valrT   s     rW   r   z'BaseMaskedArray.isin.<locals>.<genexpr>E  s'      G/2tzz***Gs   "%r   Fr|   )r   r=   rL   r  r2   rG   r   r#   rN   rr   rI   r   rQ   r   )rT   rU   r=   
values_arrr   values_have_NArV   s   `      rW   r2   zBaseMaskedArray.isin;  s    3 ZZ'
djj*-;;,Z-=-=> 3 G6@G DN "0F4::xx

((5FDu55rY   c                    | j                   | j                  }}|j                         }|j                         } t        |       ||d      S )NFr|   )rG   rI   rS   rl   )rT   r   rV   s      rW   rS   zBaseMaskedArray.copyP  s>    ZZdyy{yy{tDz$511rY   c                    t        j                  | j                  | j                        \  }} t	        |       ||d      S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        Fr|   )algosunique_with_maskrG   rI   rl   )rT   uniquesrV   s      rW   uniquezBaseMaskedArray.uniqueV  s7     ..tzz4::FtDz'4e44rY   c                    | j                   rt        d      t        |t              r|j	                  t
              }| j                  j                  |||      S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)sidesorter)r   rR   rK   r7   r   r   rG   searchsorted)rT   ru   r=  r>  s       rW   r?  zBaseMaskedArray.searchsorteda  sS     ;;$  e^,LL(Ezz&&u4&GGrY   c                   t        j                  ||      }| j                  }| j                  }|dn|}t	        |||      \  }}|j
                  | j
                  j                  k(  sJ |j
                  | j
                  f       |j                         }	||	st        |      }
nt        |      dz   }
t        j                  |
t              }|w|	ru|j                         }|dk(  rt        j                  d      }n|d | j                         dz   }|||k\  xx   dz  cc<   |||dk(  <   t        j                  ||d      }d||<    t!        |       ||      }||fS )Nr-  )na_sentinelrV   r   r   r   T)r8  resolve_na_sentinelrG   rI   r1   rN   r   rr   rq   rL   r   r   argmaxintpmaxinsertrl   )rT   rA  use_na_sentinelresolved_na_sentinelarrrV   na_sentinel_argcodesr:  has_nasizeuniques_maskna_indexna_code
uniques_eas                  rW   	factorizezBaseMaskedArray.factorizer  sV     %88oVjjzz !5 <"BV(/PTUw }}

 6 66S

8SS6+6w<D w<!#DxxD1'F{{}H1}''!*  	*..014%7"#q(#!(E%2+ii!4G$(L!T$Z6
j  rY   c                    | j                   S ra   )rG   rb   s    rW   _values_for_argsortz#BaseMaskedArray._values_for_argsort  s    zzrY   c                (   ddl m}m} ddlm} |rvt        j                  | j                  d| j                        \  }} |||      }|j                  j                  | j                        |_	        |j                  d      }|S | j                  | j                      } ||      j                         }	|	j                  }
|r|	j                  }ntt        j                  t!        |	      dz   d	
      }|	|dd | j                  j#                         |d<   |
j%                  t!        |
      | j                  j&                        }
|
j                  | j                        }
t        j(                  t!        |      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)dropnarV   )indexInt64r   int64r   Nr-  r   )pandasrV  r;   pandas.arraysr   r8  value_counts_arraylikerG   rI   rX  r   rN   value_counts_valuesrL   emptyrq   sumrF  rk   r   )rT   rW  rV  r;   r   keyscountsresr   r^  rX  rV   counts_arrays                rW   r^  zBaseMaskedArray.value_counts  sF   "	
 	/ 77

4djjLD& t,C		((4CI**W%CJ zz4::+&T{//1"" !))FXXc,/!37CF&F3BK)F2JLLUTZZ-@-@AETZZ(xxF62#FD1l%00rY   c                @   t        |       t        |      k7  ry|j                  | j                  k7  ryt        j                  | j                  |j                        sy| j
                  | j                      }|j
                  |j                      }t        ||d      S )NFT)dtype_equal)rl   rN   rL   array_equalrI   rG   r)   )rT   r   leftrights       rW   equalszBaseMaskedArray.equals  sz    :e$;;$**$ ~~djj%++6zz4::+&U[[L)e>>rY   c                   t        | j                  | j                  t        j                  ||      }| j
                  r| j                  dk(  rt        | j                         j                         rpt        j                  |j                  t              }t        | j                        rt        j                  |j                  | j                  j                         }nKt        j                  |j                  t              }n%t        j                  |j                  t              }| j#                  ||      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.
        )rV   r+  qsinterpolation   r   )rV   )r5   rG   rI   rL   r   r   ro   r  r+   r  r  rQ   r   r!   rN   r   r   r   )rT   rm  rn  rd  out_masks        rW   	_quantilezBaseMaskedArray._quantile  s     !JJ vv'
 ;; yyA~ *)"77399D9#DJJ/ ((399DJJ4J4JKC88CIIT:xx		6H&&s&::rY   )skipnac                  |dv r t        | |      d	d|i|S | j                  }| j                  }|dv rt        t        |      } |||fd|i|}|S | j                  r!| j                  dt        j                        }t        t        d|z         } ||fd||d|}t        j                  |      rt        j                  S |S )
N>   r  rr   rE  minra  prodrr  >   meanr  )rk   r   r   )r   rr  rV   rd   )r   rG   rI   r4   r   r   rL   r   r/   isnanr   r   )rT   namerr  r   r   rV   r  r   s           rW   _reducezBaseMaskedArray._reduce  s    >>&74&?f???zzzz8*D1Bd<6<V<FM ;;==RVV=<D VUT\*DEqdEfE88F== rY   c                    t        |t        j                        rR|d   }|r| j                  j	                  |      }n| j                  j                  |      }| j                  ||      S |S )Nr   r   )rK   rL   rM   rI   r  rr   r   )rT   rx  r   rr  r   r   rV   s          rW   _wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result-  s\    fbjj)&>Dzz~~4~0zz~~4~0**6488rY   rr  	min_countr   c                   t        j                  d|       d|v r|d   t        |j                  d       t	        j
                  | j                  | j                  |||      } | j                  d|f||d|S )Nrd   r   r|  ra  rr  r   )	r   validate_sumr  popr4   ra  rG   rI   r{  rT   rr  r}  r   r   r   s         rW   ra  zBaseMaskedArray.sum9  s    
F# F?e}())JJu"&&JJJJ
 +t**6
"(t
7=
 	
rY   c                   t        j                  d|       t        j                  | j                  | j
                  |||      } | j                  d|f||d|S )Nrd   r|  ru  r  )r   validate_prodr4   ru  rG   rI   r{  r  s         rW   ru  zBaseMaskedArray.prodN  sg    
V$"''JJJJ
 +t**F
#)
8>
 	
rY   r  c                   t        j                  d|       t        j                  | j                  | j
                  ||      S Nrd   r  )r   validate_minr4   rt  rG   rI   rT   rr  r   r   s       rW   rt  zBaseMaskedArray.min[  7    
F# $$JJJJ	
 	
rY   c                   t        j                  d|       t        j                  | j                  | j
                  ||      S r  )r   validate_maxr4   rE  rG   rI   r  s       rW   rE  zBaseMaskedArray.maxd  r  rY   c                  |j                  dd       t        j                  d|       | j                  j	                         }t        j                  || j                  | j                         |j                         }|r|S |s(t        |       dk(  s| j                  j                         s|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   Nrd   r   )r  r   validate_anyrG   rS   rL   putmaskrI   _falsey_valuerr   rq   rN   rk   rT   rr  r   rU   r   s        rW   rr   zBaseMaskedArray.anym  s    | 	

64 
F#" 	

64::t'9'9:MTatzz~~/?zz***rY   c                  |j                  dd       t        j                  d|       | j                  j	                         }t        j                  || j                  | j                         |j                         }|r|S |r(t        |       dk(  s| j                  j                         s|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   Nrd   r   )r  r   validate_allrG   rS   rL   r  rI   _truthy_valuer  rq   rr   rN   rk   r  s        rW   r  zBaseMaskedArray.all  s    | 	

64 
F#" 	

64::t'9'9:MSY!^4::>>3Czz***rY   )F)rU   rF   rV   rH   rS   r   returnNone)r]   type[BaseMaskedArrayT]rS   r   r  rA   )r  r'   )rf   r   r  r   )rT   rA   rf   r   r  rA   )rT   rA   rf   r   r  zBaseMaskedArrayT | Any)NNN)rT   rA   r  rA   )rN   r   rS   r   r  ztuple[np.ndarray, np.ndarray])r  r  )r  int)r  r   )r   )rT   rA   r   r  r  rA   )r   r  )rN   znpt.DTypeLike | NonerS   r   rk   r   r  rF   ).)rN   znpt.DTypeLikerS   r   r  rF   )rN   r   rS   r   r  r7   )rN   r   rS   r   r  r   )Tra   )rN   zNpDtype | Noner  rF   )r   znp.ufuncrv   r   )r  r   )rV   znpt.NDArray[np.bool_] | Noner  rH   )r  r=   )r  rF   )r]   r  r(  zSequence[BaseMaskedArrayT]r   r  r  rA   )
rT   rA   r*  r   r+  zScalar | Noner   r  r  rA   )ri  N)ru   z$NumpyValueArrayLike | ExtensionArrayr=  zLiteral['left', 'right']r>  r>   r  znpt.NDArray[np.intp] | np.intp)rA  zint | lib.NoDefaultrG  zbool | lib.NoDefaultr  z!tuple[np.ndarray, ExtensionArray])rW  r   r  r;   )rm  znpt.NDArray[np.float64]rn  r   r  rB   )rx  r   rr  r   )rx  r   )r   z
int | None)rr  r   )Gr  
__module____qualname____doc____annotations__r   r  r  rX   classmethodr_   propertyrN   r	   rg   r   r7   r{   r\   r   r   r   r   rQ   ro   r   r   r   r   rt   r   r   r   r   r   r
   r   r   r   __array_priority__r   r   r   r   r   r  _logical_methodr  r   r+   r   r%  r)  r3   r2   rS   r;  r?  rR  rT  r^  rk  rq  ry  r{  ra  ru  rt  rE  rr   r  rd   rY   rW   rB   rB   \   s    !    MM MR (=EI	& 7;%!#!CG!	! ! ( (    55&75	5 			?C	  < 6;'''/3'	&' '
P6"	      &
&
&
& 6 6BB::> '+>>	V#V V 	V
 
Vp      -^ * %$K'Z@    
0
	
R5h $O&6P*X! # # 5 5  #-  
	  !$( 4 4 	 4
 " 4  4 
 4H6*2	5 		$	$% *0"	H3H 'H 	H
 
(H &H  		!	!" ,/>>03'!('! .'! 
+	'! #'!R 		+	+, -51n 			?  ?';)';:=';	';X 48 4
 !A! 
* "Q1 
 !Q 
 !Q 
 %) O+b %) P+rY   )\
__future__r   typingr   r   r   r   r   r	   r  numpyrL   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-   r8  r.   r/   r0   pandas.core.algorithmsr1   r2   r3   pandas.core.array_algosr4    pandas.core.array_algos.quantiler5   pandas.core.arrayliker6   r   r7   pandas.core.constructionr8   pandas.core.indexersr9   pandas.core.opsr:   r[  r;   r=   r>   r?   pandas.compat.numpyr@   r   rA   rB   rd   rY   rW   <module>r     s    "      . ' : 4 2    6 6   
 6 ? * - C 4 ./
 /-5FG r+h r+rY   