
     -i                    `   S SK Jr  S SKJrJrJrJrJr  S SKrS SK	r
S SKJrJr  S SKJr  S SKJrJrJrJrJrJrJrJrJrJrJrJrJrJr  S SK J!r!J"r"  S SK#J$r$  S S	K%J&r&  S S
K'J(r(  S SK)J*r*  S SK+J,r,  S SK-J.r.J/r/J0r0J1r1J2r2J3r3  S SK4J5r5  S SK6J7r7J8r8J9r9J:r:  S SK;J<r=J>r>JrJ?r?J@r@  S SKAJBrBJCrCJDrDJErEJFrF  S SKGJHrHJIrI  S SKJJKrK  S SKLJMrM  S SKNJOrO  S SKPJQrQ  S SKRJSrTJUrUJVrV  S SKWJXrX  S SKYJZrZ  S SK[J\r\  \(       a"  S SK]J^r^J_r_  S SK`Jara  S SKbJcrc  S SKJdrdJere  S SKbJfrf  S S KgJhri   " S! S"\M\Q5      rj    S$S# jrkg)%    )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)find_stack_level)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                  l  ^  \ rS rSr% SrS\S'   S\S'   S\S'   \r\r\	SiS	 j5       r
 Sj       SkS jjr\	SS
S.SlS jj5       r\	\" \R                  5      SmS j5       5       rSjSnS jjr\SoS j5       r\SpS j5       r\SqS j5       rSrS jrSSSS.         SsS jjr\" \R,                  5       St     SuS jj5       r\	S
S.     SvS jj5       rS rSwS jrSxU 4S jjrSyS jrSzS jr\S{S  j5       r\SzS! j5       rS|S" jrS}S~S$ jjr S|S% jr!S|S& jr"\S|S' j5       r#S}SS( jjr$S|S) jr%S|S* jr&S|S+ jr'S|S, jr(SS- jr)SS
\*RV                  4       SS. jjr,\" \RZ                  5      S/ 5       r-\SSS0 jj5       r.\SSS1 jj5       r.\SSS2 jj5       r.SSS3 jjr.S4r/ S     SS5 jjr0S6\S7'   SS8 jr1SS9 jr2\SxS: j5       r3    SS; jr4S< r5\5r6SS= jr7    SS> jr8SS? jr9\S@ 5       r:\SzSA j5       r;\	 S}     SSB jj5       r<        SSC jr=S
SS#SD.       SSE jjr>SSF jr?S|SG jr@\" \R                  5       S   SSH jj5       rAS|SI jrB\" \R                  5        S       SSJ jj5       rC\" \R                  5       S   SSK jj5       rD\" \R                  5      SSL j5       rESSSM jjrFSSSN jjrG\" \R                  5      SxSO j5       rH      SSP jrISS
SQ.     SSR jjrJSSS jrKST rL  SSU jrMSS#S#SV.     SSW jjrNSS#S#SV.     SSX jjrOSS#SY.SSZ jjrPSS#S[S\.     SS] jjrQSS#S[S\.     SS^ jjrRSS#SY.SS_ jjrSSS#SY.SS` jjrTSSa jrUSS#SY.SSb jjrVSS#SY.SSc jjrW        SSd jrXSSe.     SSf jjrY          SSg jrZShr[U =r\$ )BaseMaskedArrayl   zZ
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_]_maskc                H    [         R                  U 5      nXl        X#l        U$ N)rM   __new__rQ   rS   )clsvaluesmaskresults       L/var/www/html/venv/lib/python3.13/site-packages/pandas/core/arrays/masked.py_simple_newBaseMaskedArray._simple_new}   s!     ((-    Fc                D   [        U[        R                  5      (       a  UR                  [        R                  :X  d  [        S5      eUR                  UR                  :w  a  [        S5      eU(       a   UR                  5       nUR                  5       nXl	        X l
        g )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copyrQ   rS   )selfrX   rY   rh   s       r[   __init__BaseMaskedArray.__init__   sw     4,,rxx1G2  <<4::%ABB[[]F99;D

r^   Nrc   rh   c               6    U R                  XUS9u  pEU " XE5      $ )Nrl   )_coerce_to_array)rW   scalarsrc   rh   rX   rY   s         r[   _from_sequenceBaseMaskedArray._from_sequence   s$    ++Gt+L6  r^   c                   [         R                  " XR                  S9nUR                  U R                  5        [         R
                  " U[        S9nU " X45      n[        XP5      (       a  X%R                  :w  a  [        SU S35      eU$ )Nrc   z5Default 'empty' implementation is invalid for dtype='')
ra   emptytypefillrO   onesboolr`   rc   NotImplementedError)rW   rf   rc   rX   rY   rZ   s         r[   _emptyBaseMaskedArray._empty   sv     %zz2C,,-wwuD)V"&&&%<<*?%GwaP  r^   c                    [         $ rU   )str)ri   boxeds     r[   
_formatterBaseMaskedArray._formatter   s    
r^   c                    [        U 5      erU   r   ri   s    r[   rc   BaseMaskedArray.dtype   s    !$''r^   c                    g rU    ri   items     r[   __getitem__BaseMaskedArray.__getitem__       r^   c                    g rU   r   r   s     r[   r   r      r   r^   c                    [        X5      nU R                  U   n[        U5      (       a,  U(       a  U R                  R                  $ U R
                  U   $ U R                  U R
                  U   U5      $ rU   )r?   rS   r"   rc   na_valuerQ   r\   )ri   r   newmasks      r[   r   r      sc    "4.**T"7zz***::d##

4 0'::r^   T)limit
limit_arearh   c               *   U R                   nUR                  5       (       GaU  [        R                  " XR                  S9nU R
                  R                  nUR                  nU(       a!  UR                  5       nUR                  5       nOUb  UR                  5       nU" XrUS9  Ub  UR                  5       (       d  UR                  nU) n	U	R                  5       n
[        U	5      U	S S S2   R                  5       -
  S-
  nUS:X  a'  US U
=== US U
 -  sss& XS-   S === X[S-   S  -  sss& OUS:X  a  XS-   U=== XZS-   U -  sss& U(       a&  U R                  UR                  UR                  5      $ U $ U(       a  U R                  5       nU$ U nU$ )Nndimr   rY      insideoutside)rS   anyr
   get_fill_funcr   rQ   Trh   allargmaxlenr\   )ri   methodr   r   rh   rY   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                r[   _pad_or_backfill BaseMaskedArray._pad_or_backfill   sn    zz88::((ii@Dzz||HvvH#==?#==?'yy{X6%dhhjjvv 5 )8}x"~'<'<'>>B)Ve$Ve4$AXZ(D,<<(9,QY.$qy42HH.''

HJJ??!YY[
  "
r^   c                T   [        X5      u  pU R                  n[        R                  " X[	        U 5      5      nUR                  5       (       a  Ub  [        R                  " X R                  S9nU R                  R                  nUR                  nU(       a   UR                  5       nUR                  5       nU" XsUS9  U R                  UR                  UR                  5      $ U(       a  U R                  5       n	OU S S  n	XU'    U	$ U(       a  U R                  5       n	U	$ U S S  n	U	$ )Nr   r   )r    rS   r
   check_value_sizer   r   r   r   rQ   r   rh   r\   )
ri   valuer   r   rh   rY   r   r   r   r   s
             r[   fillnaBaseMaskedArray.fillna   s     /u=zz((c$i@88::!,,V))D::<<66'}}H'}}HX:''

HJJ?? !%J!%aJ#(4  	 !YY[
  "!W
r^   rh   c                   [        U 5      erU   r   )rW   rX   rc   rh   s       r[   rn    BaseMaskedArray._coerce_to_array  s     "#&&r^   c                   U R                   R                  nUS:X  a  [        R                  " U5      (       a  U$ OUS:X  a9  [        R                  " U5      (       d  [        R
                  " U5      (       a  U$ OM[        R                  " U5      (       d0  [        R
                  " U5      (       a  UR	                  5       (       a  U$ [        SU< SU R                    S35      e)zQ
Check if we have a scalar that we can cast losslessly.

Raises
------
TypeError
bfzInvalid value 'z' for dtype 'rt   )rc   kindr	   r"   
is_integeris_floatre   )ri   r   r   s      r[   _validate_setitem_value'BaseMaskedArray._validate_setitem_value  s     zz3;{{5!! " S[~~e$$U(;(; )< ~~e$$e)<)<AQAQASAS
 /%-

|1MNNr^   c                Z   [        X5      n[        U5      (       aY  [        X R                  5      (       a  SU R                  U'   g U R                  U5      nX R                  U'   SU R                  U'   g U R                  X R                  S9u  p#X R                  U'   X0R                  U'   g )NTFrs   )r?   r%   r*   rc   rS   r   rQ   rn   )ri   keyr   rY   s       r[   __setitem__BaseMaskedArray.__setitem__4  s    !$,U$UJJ77"&

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

3"'

3++E+D

3

3r^   c                  > [        U5      (       a  XR                  R                  La  U R                  R                  R                  S:X  a`  [
        R                  " U5      (       aE  [        [        R                  " U R                  5      U R                  ) -  R                  5       5      $ [        [        TU ]5  U5      5      $ )Nr   )r+   rc   r   rQ   r   r	   r   ry   ra   isnanrS   r   super__contains__)ri   r   	__class__s     r[   r   BaseMaskedArray.__contains__E  s    99JJ$7$77zz$$+S0A0ARXXdjj1TZZK?DDFGGEG(-..r^   c              #  b  #    U R                   S:X  az  U R                  (       d  U R                   H  nUv   M	     g U R                  R                  n[        U R                  U R                  5       H  u  p1U(       a  Uv   M  Uv   M     g [        [        U 5      5       H	  nX   v   M     g 7f)Nr   )	r   _hasnarQ   rc   r   ziprS   ranger   )ri   valr   isna_is        r[   __iter__BaseMaskedArray.__iter__M  s     99>;;::CI &  ::.."%djj$**"=JE&!		 #> 3t9%g &s   B-B/c                ,    [        U R                  5      $ rU   )r   rQ   r   s    r[   __len__BaseMaskedArray.__len__]  s    4::r^   c                .    U R                   R                  $ rU   )rQ   rf   r   s    r[   rf   BaseMaskedArray.shape`  s    zzr^   c                .    U R                   R                  $ rU   )rQ   r   r   s    r[   r   BaseMaskedArray.ndimd  s    zzr^   c                    U R                   R                  X5      nU R                  R                  X5      nU R                  X45      $ rU   )rQ   swapaxesrS   r\   )ri   axis1axis2datarY   s        r[   r   BaseMaskedArray.swapaxesh  s;    zz""50zz""50++r^   r   c                    [         R                  " U R                  XS9n[         R                  " U R                  XS9nU R	                  X45      $ Naxis)ra   deleterQ   rS   r\   )ri   locr   r   rY   s        r[   r   BaseMaskedArray.deletem  s;    yyS4yyS4++r^   c                    U R                   R                  " U0 UD6nU R                  R                  " U0 UD6nU R                  X45      $ rU   )rQ   reshaperS   r\   ri   argskwargsr   rY   s        r[   r   BaseMaskedArray.reshaper  sE    zz!!4262zz!!4262++r^   c                    U R                   R                  " U0 UD6nU R                  R                  " U0 UD6n[        U 5      " X45      $ rU   )rQ   ravelrS   rv   r   s        r[   r   BaseMaskedArray.ravelw  sC    zz00zz00Dz$%%r^   c                v    U R                  U R                  R                  U R                  R                  5      $ rU   )r\   rQ   r   rS   r   s    r[   r   BaseMaskedArray.T}  s%    

djjll;;r^   c                    U R                   R                  S:X  a  U $ [        R                  " X#5        [        R
                  " U R                  4SU0UD6nU R                  X@R                  R                  5       5      $ )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   decimals)
rc   r   nvvalidate_roundra   roundrQ   _maybe_mask_resultrS   rh   )ri   r   r   r   rX   s        r[   r   BaseMaskedArray.round  sa    0 ::??c!K
$'$**BxB6B &&vzz/@AAr^   c                l    U R                  U R                  ) U R                  R                  5       5      $ rU   r\   rQ   rS   rh   r   s    r[   
__invert__BaseMaskedArray.__invert__  &    TZZ__->??r^   c                l    U R                  U R                  * U R                  R                  5       5      $ rU   r   r   s    r[   __neg__BaseMaskedArray.__neg__  r   r^   c                "    U R                  5       $ rU   r   r   s    r[   __pos__BaseMaskedArray.__pos__  s    yy{r^   c                |    U R                  [        U R                  5      U R                  R	                  5       5      $ rU   )r\   absrQ   rS   rh   r   s    r[   __abs__BaseMaskedArray.__abs__  s(    DJJ1BCCr^   c                4    [         R                  " U [        S9$ )Nrs   )ra   asarrayobjectr   s    r[   _values_for_json BaseMaskedArray._values_for_json  s    zz$f--r^   c                ~   U R                   n[        XX45      u  pUc  [        nU(       a  U[        :w  a2  [        U5      (       d"  U[        R
                  L a  [        SU S35      e[        R                  " 5          [        R                  " S[        S9  U R                  R                  U5      nSSS5        UWU R                  '   U$ [        R                  " 5          [        R                  " S[        S9  U R                  R                  XS9nSSS5        U$ ! , (       d  f       Nq= f! , (       d  f       W$ = f)a  
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   r:   r  r&   
libmissingNArg   warningscatch_warningsfilterwarningsRuntimeWarningrQ   astyperS   )ri   rc   rh   r   hasnar   s         r[   to_numpyBaseMaskedArray.to_numpy  s   D 24P=E'..
- )% 1& &  ((*''>Jzz((/ +  (D
  ((*''>Jzz(((: +  +*
 +* s   <5D3D-
D*-
D<c                   U R                   S:  a   U  Vs/ s H  oR                  5       PM     sn$ U R                  (       a  S OU R                  R                  nU R                  U[        R                  S9R                  5       $ s  snf )Nr   rc   r   )r   tolistr   rQ   rc   r  r  r  )ri   xrc   s      r[   r  BaseMaskedArray.tolist  sb    99q=(,-1HHJ--)9)9}}5:==}AHHJJ .s   Bc                    g rU   r   ri   rc   rh   s      r[   r  BaseMaskedArray.astype  r   r^   c                    g rU   r   r  s      r[   r  r    r   r^   c                    g rU   r   r  s      r[   r  r  !  r   r^   c                   [        U5      nXR                  :X  a  U(       a  U R                  5       $ U $ [        U[        5      (       a  [
        R                  " 5          [
        R                  " S[        S9  U R                  R                  UR                  US9nS S S 5        WU R                  L a  U R                  OU R                  R                  5       nUR                  5       nU" X4SS9$ [        U[        5      (       a   UR                  5       nUR                  XUS9$ UR                   S:X  a  ["        R$                  nO7UR                   S:X  a  ["        R&                  " S5      nO[(        R*                  nUR                   S	;   a  U R,                  (       a  [/        S
5      eUR                   S:X  a  U R,                  (       a  [/        S5      eU R1                  XUS9nU$ ! , (       d  f       GNR= f)Nr  r	  r   Frl   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)rc   r   rh   )r'   rc   rh   r`   r(   r  r  r  r  rQ   r  numpy_dtyperS   construct_array_typer!   rp   r   ra   nan
datetime64r	   
no_defaultr   rg   r  )ri   rc   rh   r   rY   rW   eaclsr   s           r[   r  r  %  s   U#JJyy{"K e_--((*''>Jzz(():):(F + "&!34::9JD,,.Ct..e^,,..0E'''EE
 ::vvHZZ3}}U+H~~H ::$++;<<::?@@}}5$}GC +*s   >G''
G6i  c                    USL aR  U R                   (       d  [        R                  " U R                  XS9$ [        R
                  " S[        [        5       S9  Uc  SnU R                  XS9$ )zd
the array interface, return my values
We return an object array here to preserve our scalar values
Frl   aS  Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.)
stacklevel)	r   ra   r<   rQ   r  warnFutureWarningr   r  r  s      r[   	__array__BaseMaskedArray.__array__U  s`     5=;;xx

%CCMM2 +-	 <D}}5}44r^   ztuple[type, ...]_HANDLED_TYPESc                j  ^	^
 UR                  SS5      nX5-    H-  n[        X`R                  [        4-   5      (       a  M'  [        s  $    [
        R                  " XU/UQ70 UD6nU[        La  U$ SU;   a  [
        R                  " XU/UQ70 UD6$ US:X  a&  [
        R                  " XU/UQ70 UD6nU[        La  U$ [        R                  " [        U 5      [        S9m	/ nU HU  n[        U[        5      (       a,  T	UR                  -  m	UR                  UR                  5        MD  UR                  U5        MW     SU	4S jjm
[!        X5      " U0 UD6nUR"                  S:  a  [%        U
4S jU 5       5      $ US:X  a-  U R                  R'                  5       (       a  U R(                  $ U$ T
" U5      $ )	Noutr   reducers   c                  > SSK JnJnJn  U R                  R
                  S:X  a  TR                  5       nU" X5      $ U R                  R
                  S;   a  TR                  5       nU" X5      $ U R                  R
                  S:X  aU  TR                  5       nU R                  [        R                  :X  a  U R                  [        R                  5      n U" X5      $ [        R                  U T'   U $ )Nr   )rF   rJ   IntegerArrayr   r"  r   )pandas.core.arraysrF   rJ   r4  rc   r   rh   ra   float16r  float32r%  )r  rF   rJ   r4  mrY   s        r[   reconstruct4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s      ww||s"IIK#A))%IIK#A))$IIK77bjj( ,A$Q**&&$Hr^   r   c              3  4   >#    U  H  nT" U5      v   M     g 7frU   r   ).0r  r9  s     r[   	<genexpr>2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s     8AQs   )r  rP   )getr`   r/  rM   NotImplementedr.   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncra   zerosr   ry   rS   appendrQ   getattrnouttupler   	_na_value)ri   ufuncr   inputsr   r1  r  rZ   inputs2rY   r9  s            @@r[   __array_ufunc__BaseMaskedArray.__array_ufunc__r  s    jj#Aa!4!47I!IJJ%% 
 <<
"(
,2
 'MF?44V&,06  X77V&,06F ^+xxD	.A!_--qww'q! 	4 ';F;::>8888xzz~~~~%Mv&&r^   c                T    SSK nUR                  U R                  U R                  US9$ )z&
Convert myself into a pyarrow Array.
r   N)rY   rv   )pyarrowr<   rQ   rS   )ri   rv   pas      r[   __arrow_array__BaseMaskedArray.__arrow_array__  s$     	xx

$x??r^   c                6    U R                   R                  5       $ rU   )rS   r   r   s    r[   r   BaseMaskedArray._hasna  s     zz~~r^   c                   Ucl  U R                   R                  5       nU[        R                  L a  US-  nU$ [	        U5      (       a&  [        U5      [        U5      :X  a  U[        U5      -  nU$ U R                   U-  nU$ )NT)rS   rh   r  r  r$   r   r+   )ri   rY   others      r[   _propagate_maskBaseMaskedArray._propagate_mask  s}     <::??$D
%d{  e$$Us4y)@d5k)
  ::$D r^   c                Z   UR                   nS n[        US5      (       d=  [        U5      (       a-  [        U5      [        U 5      :X  a  [	        U5      n[        USS9n[        U[        5      (       a  UR                  UR                  pAOV[        U5      (       aF  [        U[        5      (       d  [        R                  " U5      nUR                  S:  a  [        S5      e[        R                   " U[        U 5      45      n[        R"                  " U5      n[%        U5      nUS;   a*  [        U[        R&                  5      (       a  [)        U5      nU R+                  XA5      nU[,        R.                  L a  [        R0                  " U R                  5      nU R2                  R4                  S:X  a2  US;   a  [        S	U S
35      eUS;   a  SnOSnUR7                  U5      nOSU;   a9  U R2                  R4                  S:w  a  UR7                  [        R8                  5      nORU R2                  R4                  S;   a  US;   a  Un[        R:                  " SS9   U" U R                  U5      nS S S 5        US:X  a  [        R<                  " U R                  S:H  U R                  ) -  SU5      nUb   [        R<                  " US:H  U) -  SU5      nOU[,        R.                  La  [        R<                  " US:H  SU5      nOUS:X  a  Ub   [        R<                  " US:H  U) -  SU5      nO.U[,        R.                  La  [        R<                  " US:H  SU5      n[        R<                  " U R                  S:H  U R                  ) -  SU5      nU R?                  WU5      $ ! , (       d  f       GN6= f)Nrc   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int8ry   r_  r   r"  )r`  rc  r  )r   r]  Fr   r^  ) __name__hasattrr$   r   pd_arrayr>   r`   rM   rQ   rS   r;   ra   r  r   rz   r0   maybe_prepare_scalar_for_opget_array_opr=   rd   ry   rX  r  r  	ones_likerc   r   r  float64errstatewherer   )	ri   rW  opop_nameomaskpd_oprY   rZ   rc   s	            r[   _arith_methodBaseMaskedArray._arith_method  s   ++ w''U##E
c$i' UOE!%t<Ee_-- ;;5%  e^44

5)zzA~)*TUU //D	|D  $.u5o%*UBHH*E*E KE##E1JMM!\\$**-Fzz#%   .$WI-NO  o-"E"Eu-g%$**//S*@  rzz2 zz$&76I+I *tzz51 + 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+ +*s   N
N*c                   SSK Jn  S n[        U[        5      (       a  UR                  UR
                  pAOd[        U5      (       aT  [        R                  " U5      nUR                  S:  a  [        S5      e[        U 5      [        U5      :w  a  [        S5      eU[        R                  L aS  [        R                  " U R                  R                   SS9n[        R"                  " U R                  R                   SS9nO[$        R&                  " 5          [$        R(                  " SS	[*        5        [$        R(                  " SS	[,        5        [/        U R                  S
UR0                   S
35      nU" U5      nU[2        L a  [5        U R                  X5      nS S S 5        U R7                  XA5      nU" WUSS9$ ! , (       d  f       N'= f)Nr   rE   r   r\  zLengths must match to comparery   rs   r  elementwise__Fr   )r5  rF   r`   rM   rQ   rS   r$   ra   r  r   rz   r   rg   r  r  rD  rf   rx   r  r  r  r,  DeprecationWarningrF  rf  r@  r@   rX  )ri   rW  ro  rF   rY   rZ   r   s          r[   _cmp_methodBaseMaskedArray._cmp_method?  sT   3e_--++u{{4%  JJu%EzzA~)*TUU4yCJ& !@AAJMM!
 XXdjj..f=F774::++6:D((* ''-O''-AST r"++b-AB^+/

EFF + ##D0FDu55 +*s   BF::
Gc                   [        U[        5      (       a&  Uu  p4U R                  X25      U R                  XB5      4$ UR                  R                  S:X  a  SSKJn  U" XSS9$ UR                  R                  S:X  a  SSKJn  U" XSS9$ [        R                  " UR                  S5      (       ah  [        UR                  5      (       aN  SS	KJn  UR                  R                  S
5      X'   [        X5      (       d  UR                  XR                  S9$ U$ UR                  R                  S;   a  SSKJn  U" XSS9$ [        R                   X'   U$ )zW
Parameters
----------
result : array-like or tuple[array-like]
mask : array-like bool
r   r   rI   Fr   r   rE   r8  )TimedeltaArrayr!  rs   r"  r4  )r`   rH  r   rc   r   r5  rJ   rF   r	   is_np_dtyper   r|  rv   r\   r4  ra   r%  )	ri   rZ   rY   divrc  rJ   rF   r|  r4  s	            r[   r   "BaseMaskedArray._maybe_mask_resultg  s    fe$$HC''2''2 
 <<#8 E::\\#%7599__V\\3//4Fv||4T4T9!<<,,U3FLf55%11&1MMM\\$&7599 66FLMr^   c                6    U R                   R                  5       $ rU   )rS   rh   r   s    r[   r+   BaseMaskedArray.isna  s    zz  r^   c                .    U R                   R                  $ rU   r  r   s    r[   rI  BaseMaskedArray._na_value  s    zz"""r^   c                \    U R                   R                  U R                  R                  -   $ rU   )rQ   nbytesrS   r   s    r[   r  BaseMaskedArray.nbytes  s!    zz  4::#4#444r^   c                    [         R                  " U Vs/ s H  o3R                  PM     snUS9n[         R                  " U Vs/ s H  o3R                  PM     snUS9nU " XE5      $ s  snf s  snf r   )ra   concatenaterQ   rS   )rW   	to_concatr   r  r   rY   s         r[   _concat_same_type!BaseMaskedArray._concat_same_type  sX     ~~	:	1ww	:F~~	:	1ww	:F4 ;:s   A'A,c                   [        U R                  XUS9n[        U R                  R                  5      X@R                  5       '   U$ )N)encodinghash_key
categorize)rA   rQ   hashrc   r   r+   )ri   r  r  r  hashed_arrays        r[   _hash_pandas_object#BaseMaskedArray._hash_pandas_object  s>     "JJ
 %))<)<$=YY[!r^   )
allow_fill
fill_valuer   c               *   [        U5      (       a  U R                  OUn[        U R                  UUUUS9n[        U R                  USX$S9nU(       a1  [        U5      (       a!  [        R                  " U5      S:H  nX6U'   Xx-  nU R                  Xg5      $ )N)r  r  r   Tr   )	r+   rO   r5   rQ   rS   r,   ra   r  r\   )	ri   indexerr  r  r   data_fill_valuerZ   rY   	fill_masks	            r[   r5   BaseMaskedArray.take  s     8<J7G7G$33ZJJ&!
 JJDZ
 %
++

7+r1I *9#D--r^   c                l  ^  SSK Jn  [        R                  " U5      n[	        T R
                  U5      nT R                  (       a=  UR                  [        :H  =(       a    [        U 4S jU 5       5      nXTT R                  '   [        R                  " T R
                  R                  [        S9nU" XFSS9$ )Nr   rE   c              3  R   >#    U  H  oTR                   R                  L v   M     g 7frU   r  )r<  r   ri   s     r[   r=  'BaseMaskedArray.isin.<locals>.<genexpr>  s"      @6@stzz***js   $'rs   Fr   )r5  rF   ra   r  r2   rQ   r   rc   r  r   rS   rD  rf   ry   )ri   rX   rF   
values_arrrZ   values_have_NArY   s   `      r[   r2   BaseMaskedArray.isin  s    3 ZZ'
djj*-;;'--7 C @6@@ =N "04::xx

((5Fu55r^   c                    U R                   R                  5       nU R                  R                  5       nU R                  X5      $ rU   )rQ   rh   rS   r\   )ri   r   rY   s      r[   rh   BaseMaskedArray.copy  s3    zz zz ++r^   c                \    U R                   nU R                  n[        R                  " X!US9$ )N)keeprY   )rQ   rS   algos
duplicated)ri   r  rX   rY   s       r[   r  BaseMaskedArray.duplicated  s)     zz==r^   c                ~    [         R                  " U R                  U R                  5      u  pU R	                  X5      $ )zZ
Compute the BaseMaskedArray of unique values.

Returns
-------
uniques : BaseMaskedArray
)r  unique_with_maskrQ   rS   r\   )ri   uniquesrY   s      r[   uniqueBaseMaskedArray.unique  s1     ..tzz4::F..r^   c                    U R                   (       a  [        S5      e[        U[        5      (       a  UR	                  [
        5      nU R                  R                  XUS9$ )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)sidesorter)r   rg   r`   r;   r  r  rQ   searchsorted)ri   r   r  r  s       r[   r  BaseMaskedArray.searchsorted  sT     ;;$  e^,,LL(Ezz&&u&GGr^   c                   U R                   nU R                  n[        USUS9u  pEUR                  U R                  R                  :X  d   UR                  U R                  45       eUR                  5       nU(       d  U(       d  [        U5      nO[        U5      S-   n[        R                  " U[        S9nU(       d{  U(       at  UR                  5       n	U	S:X  a  [        R                  " S5      n
OUS U	 R                  5       S-   n
XDU
:  ==   S-  ss'   XUS:H  '   [        R                  " XZS5      nSX'   U R                  XX5      nXK4$ )NT)use_na_sentinelrY   r   rs   r   r   )rQ   rS   r1   rc   r#  r   r   ra   rD  ry   r   intpmaxinsertr\   )ri   r  arrrY   codesr  has_nasizeuniques_maskna_indexna_code
uniques_eas               r[   	factorizeBaseMaskedArray.factorize  s   
 jjzz )dN }}

 6 66S

8SS6&w<D w<!#DxxD16{{}H1}''!*	*..0147"#q(#!(%2+ii!4G$(L!%%g<
  r^   c                    U R                   $ rU   )rQ   r   s    r[   _values_for_argsort#BaseMaskedArray._values_for_argsort:  s    zzr^   c                r   SSK JnJn  SSKJn  [
        R                  " U R                  XR                  S9u  pVn[        R                  " [        U5      4[        R                  S9nUR                  5       n	US:  a  SUS'   U" Xi5      n
U" U R                  R                  5       " XX5      5      nU" XSS	S
9$ )z
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   )IndexrD   r}  dropnarY   rs   Tr   countF)indexnamerh   )pandasr  rD   pandas.arraysr4  r  value_counts_arraylikerQ   rS   ra   rD  r   rd   rh   rc   r$  )ri   r  r  rD   r4  keysvalue_counts
na_counter
mask_indexrY   r  r  s               r[   r  BaseMaskedArray.value_counts>  s    "	
 	/).)E)EJJvJJ*
&J XXs<02"((C
 >!JrN<.JJ++-

 cW5AAr^   c                .   U(       aL  [        U R                  XR                  S9n[        R                  " UR
                  [        R                  S9nO [        U R                  XR                  S9u  p#[        U 5      " X#5      nX"R                  5          $ )Nr  rs   )	r4   rQ   rS   ra   rD  rf   rd   rv   argsort)ri   r  rZ   res_masks       r[   _modeBaseMaskedArray._modef  sf    $**V**EFxxBHH=H#DJJvJJOFdF-nn&''r^   c                J   [        U 5      [        U5      :w  a  gUR                  U R                  :w  a  g[        R                  " U R                  UR                  5      (       d  gU R
                  U R                  )    nUR
                  UR                  )    n[        X#SSS9$ )NFT)
strict_nandtype_equal)rv   rc   ra   array_equalrS   rQ   r)   )ri   rW  leftrights       r[   equalsBaseMaskedArray.equalso  s}    :e$;;$**$ ~~djj%++66zz4::+&U[[L)$OOr^   c                   [        U R                  U R                  [        R                  UUS9nU R
                  (       a  U R                  S:X  a  [        eU R                  5       R                  5       (       aq  [        R                  " UR                  [        S9n[        U R                  5      (       a3  [        R                  " UR                  U R                  R                   S9nOG[        R                  " UR                  [        S9nO#[        R                  " UR                  [        S9nU R#                  X4S9$ )z
Dispatch to quantile_with_mask, needed because we do not have
_from_factorized.

Notes
-----
We assume that all impacted cases are 1D-only.
)rY   r  qsinterpolation   rs   rY   )r8   rQ   rS   ra   r%  r   r   rz   r+   r   rx   rf   ry   r#   rc   rD  r#  r   )ri   r  r  resout_masks        r[   	_quantileBaseMaskedArray._quantile  s     !JJ vv'
 ;; yyA~ *)yy{  77399D9#DJJ// ((399DJJ4J4JKC88CIIT:xx		6H&&s&::r^   )skipnakeepdimsc                  US;   a  [        X5      " SSU0UD6nOIU R                  nU R                  n[        [        SU 35      nUR	                  SS 5      n	U" U4XUS.UD6nU(       a\  [        U5      (       a  U R                  USSS9$ UR                  S	5      n[        R                  " S	[        S
9nU R                  XW5      $ [        U5      (       a  [        R                  $ U$ )N>	   r   r   r  minstdsumvarmeanprodr  r%  r   )r   r  rY   r   )r   )r  r   	mask_sizer   rs   r   )rF  rQ   rS   r/   popr+   _wrap_na_resultr   ra   rD  ry   r   r  r  )
ri   r  r  r  r   rZ   r   rY   ro  r   s
             r[   _reduceBaseMaskedArray._reduce  s     TTT(AA&AF ::D::D3tf.B::fd+DL4TLVLFF||++A+NN*xx...v<<<<== Mr^   c                   [        U[        R                  5      (       aK  U(       a  U R                  R	                  US9nOU R                  R                  US9nU R                  X%5      $ U$ r   )r`   ra   rb   rS   r   r   r   )ri   r  rZ   r  r   rY   s         r[   _wrap_reduction_result&BaseMaskedArray._wrap_reduction_result  sT    fbjj))zz~~4~0zz~~4~0**688r^   c                  [         R                  " U[        S9nU R                  S:X  a  SOSnUS;   a  UnOUS;   d  U R                  R                  S:X  a!  U R                  R
                  R                  nON[        5       =(       d    [        (       + nU(       a  SOS	nU(       a  S
OSn	XXS.U R                  R                     n[         R                  " S/US9n
U R                  XS9$ )Nrs   Float32r7  rl  )r  medianr  r  skewkurt)r  r     int32int64uint32uint64)r   r   ur   r   r  )ra   rx   ry   rc   itemsizer#  r  r   r   r   r<   r   )ri   r  r   r  rY   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              r[   r  BaseMaskedArray._wrap_na_result  s    wwy-"&**	"9Yy
CC!H^#tzz':':a'?zz--22H"5"7"Ct8"5w7H$7XI%9V

H !H-&&u&88r^   c                   US:X  aR  [        U[        R                  5      (       a3  U R                  U[        R                  " UR
                  [        S95      $ U R                  XX5S9$ )Nr   rs   r  r   )r`   ra   rb   r   rD  rf   ry   r  )ri   r  rZ   r  	min_countr   s         r[    _wrap_min_count_reduction_result0BaseMaskedArray._wrap_min_count_reduction_result  sT     >j<<**6288FLLPT3UVV**4*RRr^   r  r  r   c                   [         R                  " SU5        [        R                  " U R                  U R
                  UUUS9nU R                  SXQX#S9$ )Nr   r  r  )r   validate_sumr7   r  rQ   rS   r  ri   r  r  r   r   rZ   s         r[   r  BaseMaskedArray.sum  sZ     	F#"&&JJJJ
 446I 5 
 	
r^   c                   [         R                  " SU5        [        R                  " U R                  U R
                  UUUS9nU R                  SXQX#S9$ )Nr   r  r  )r   validate_prodr7   r  rQ   rS   r  r  s         r[   r  BaseMaskedArray.prod  s\     	V$"''JJJJ
 44FY 5 
 	
r^   r  c                   [         R                  " SU5        [        R                  " U R                  U R
                  UUS9nU R                  SXAUS9$ )Nr   r  r  )r   validate_meanr7   r  rQ   rS   r  ri   r  r   r   rZ   s        r[   r  BaseMaskedArray.mean  sP    
V$"''JJJJ	
 **66t*TTr^   r   r  r   ddofc                   [         R                  " SUSS9  [        R                  " U R                  U R
                  UUUS9nU R                  SXQUS9$ )Nr   r  fnamer  r  )r   validate_stat_ddof_funcr7   r  rQ   rS   r  ri   r  r   r  r   rZ   s         r[   r  BaseMaskedArray.var  W     	""2vU;"&&JJJJ
 **5&d*SSr^   c                   [         R                  " SUSS9  [        R                  " U R                  U R
                  UUUS9nU R                  SXQUS9$ )Nr   r  r!  r  r  )r   r#  r7   r  rQ   rS   r  r$  s         r[   r  BaseMaskedArray.std+  r&  r^   c                   [         R                  " SU5        [        R                  " U R                  U R
                  UUS9nU R                  SXAUS9$ )Nr   r  r  )r   validate_minr7   r  rQ   rS   r  r  s        r[   r  BaseMaskedArray.min8  N    
F#"&&JJJJ	
 **5&d*SSr^   c                   [         R                  " SU5        [        R                  " U R                  U R
                  UUS9nU R                  SXAUS9$ )Nr   r  r  )r   validate_maxr7   r  rQ   rS   r  r  s        r[   r  BaseMaskedArray.maxB  r,  r^   c                2    [        U R                  5       XS9$ )N)	na_action)r3   r  )ri   mapperr1  s      r[   mapBaseMaskedArray.mapL  s    &FFr^   c                  [         R                  " SU5        U R                  R                  5       n[        R
                  " X@R                  U R                  5        UR                  5       nU(       a  U$ U(       d.  [        U 5      S:X  d  U R                  R                  5       (       d  U$ U R                  R                  $ )a  
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>
r   r   )r   validate_anyrQ   rh   ra   putmaskrS   _falsey_valuer   r   rc   r   ri   r  r   r   rX   rZ   s         r[   r   BaseMaskedArray.anyO  s    ~ 	F#" 	

6::t'9'9:MTatzz~~/?/?zz***r^   c                  [         R                  " SU5        U R                  R                  5       n[        R
                  " X@R                  U R                  5        UR                  US9nU(       a  U$ U(       a.  [        U 5      S:X  d  U R                  R                  5       (       d  U$ U R                  R                  $ )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.
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
r   r   r   )r   validate_allrQ   rh   ra   r7  rS   _truthy_valuer   r   r   rc   r   r9  s         r[   r   BaseMaskedArray.all  s    ~ 	F#" 	

6::t'9'9:&MSY!^4::>>3C3Czz***r^   c                  U R                   R                  S:X  aU  U(       a5  U R                  R                  5       n	U R                  R                  5       n
OU R                  n	U R                  n
OjU R                   R                  S;   a8  SnU R                  R                  S5      n	U R                  R                  5       n
O[        SU R                    35      e[        R                  " U	4USUUUUU
S.UD6  U(       d  U $ U R                   R                  S:X  a  [        U 5      R                  X5      $ SSKJn  UR                  " X5      $ )	z"
See NDFrame.interpolate.__doc__.
r   r"  Tf8z)interpolate is not implemented for dtype=r   )r   r   r  r   limit_directionr   rY   rI   )rc   r   rQ   rh   rS   r  rz   r
   interpolate_2d_inplacerv   r\   r5  rJ   )ri   r   r   r  r   rA  r   rh   r   r   rY   rJ   s               r[   interpolateBaseMaskedArray.interpolate  s     ::??c!zz(zz(zzzzZZ__$D::$$T*D::??$D%;DJJ<H  	&&
	
+!
	
 
	
 K::??c!:))$558 ,,T88r^   )r  c                   U R                   nU R                  n[        [        U5      nU" XE4SU0UD6u  pEU R	                  XE5      $ )Nr  )rQ   rS   rF  r6   r\   )ri   r  r  r   r   rY   ro  s          r[   _accumulateBaseMaskedArray._accumulate&  sJ     zzzz)40<6<V<
++r^   c          	     F   SSK Jn  UR                  U5      nU" XUS9n	U R                  n
U	R                  S:w  a  U
R                  5       nO[        R                  " U[        S9nUS:X  a  UR                  S5      S;   a  S	US S & U	R                  " U R                  4UUUU
US
.UD6nU	R                  S:X  aH  U	R                  R                  U	R                  S5      n[        R                  " XS45      R                  nU	R                  S;   a  U$ U R!                  X5      $ )Nr   )WrappedCythonOp)howr   has_dropped_na	aggregaters   rank	na_option)topbottomF)r  ngroupscomp_idsrY   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsrI  get_kind_from_howrS   r   rh   ra   rD  ry   r?  _cython_op_ndim_compatrQ   rJ  _cython_aritytiler   r   )ri   rJ  rK  r  rQ  idsr   rI  r   ro  rY   rS  
res_valuesaritys                 r[   _groupby_opBaseMaskedArray._groupby_op4  s    	<005O zz77k!))+K((7$7K&=VZZ48II"KN..JJ
#
 

 66V$$((3E''+qz:<<K66)) **:CCr^   )rQ   rS   )rX   rP   rY   rR   returnr   )F)rX   rP   rY   rR   rh   ry   ra  None)rh   ry   ra  r   )rf   r   rc   r!   )r   ry   ra  zCallable[[Any], str | None])ra  r(   )r   r   ra  r   )r   r   ra  r   )r   r   ra  z
Self | Any)
r   r   r   
int | Noner   z#Literal['inside', 'outside'] | Nonerh   ry   ra  r   )NNNT)r   rc  rh   ry   ra  r   )rc   r   rh   ry   ra  ztuple[np.ndarray, np.ndarray])ra  rb  )ra  ry   )ra  rB   )ra  int)ra  r   )ra  r   )r   )r   r   ra  r   )r   rd  )ra  rP   )rc   znpt.DTypeLike | Nonerh   ry   r   r  ra  rP   ).)rc   znpt.DTypeLikerh   ry   ra  rP   )rc   r!   rh   ry   ra  r;   )rc   r   rh   ry   ra  r   )T)NN)rc   zNpDtype | Nonerh   zbool | Nonera  rP   )rJ  znp.ufuncr   r~   rU   )rY   znpt.NDArray[np.bool_] | Nonera  rR   )ra  rF   )rZ   z*np.ndarray | tuple[np.ndarray, np.ndarray]rY   rP   )r  zSequence[Self]r   r   ra  r   )r  r~   r  r~   r  ry   ra  znpt.NDArray[np.uint64])r  ry   r  zScalar | Noner   r   ra  r   )rX   r   ra  rF   )r   )r  zLiteral['first', 'last', False]ra  rR   )r  N)r   z$NumpyValueArrayLike | ExtensionArrayr  zLiteral['left', 'right']r  zNumpySorter | Nonera  znpt.NDArray[np.intp] | np.intp)r  ry   ra  z!tuple[np.ndarray, ExtensionArray])r  ry   ra  rD   )r  ry   ra  r   )r  znpt.NDArray[np.float64]r  r~   ra  rM   )r  r~   r  ry   r  ry   )r  r~   )r  ry   r  rd  r   AxisInt | None)r  ry   r   re  )r  ry   r   re  r  rd  )r   r   r   rd  rh   ry   ra  rJ   )r  r~   r  ry   ra  rM   )
rJ  r~   rK  ry   r  rd  rQ  rd  r\  znpt.NDArray[np.intp])]rf  
__module____qualname____firstlineno____doc____annotations__r   r=  r8  classmethodr\   rj   rp   r   r;   r{   r   propertyrc   r   r   r   r   rn   r   r   r   r   r   rf   r   r   r   r   r   r   r   r   r   r   r   r  r	   r'  r  r  r  __array_priority__r-  rM  rR  r   rX  rs  _logical_methodry  r   r+   rI  r  r  r  r5   r2   rh   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r3  r   r   rC  rF  r_  __static_attributes____classcell__)r   s   @r[   rM   rM   l   s    !    MM  MR (=EI	& .2 ! ! 			   	 ( (    
;  !:>* * 	*
 8* * 
*X 			NR.8GK	  B 6;'''/3'	&' '
O6"/       ,
,
,
& < <BF@@D
.
 '+>>	[#[ [ 	[
 
[z 			K  K      ,\  AE5#52=5	56 %$K'Z@    0	 [5z $O&6P-@-HR-^! # # 5 5  !  
	 *-;?	 !$( . 	 .
 " .  . 
 .H6(,
 		"	"#6=>3>	> $>	/ 		$	$% *0%)	H3H 'H #	H
 
(H &H  		!	!" !%"!"! 
+"! #"!H 		+	+, -&BP( 			P  P';)';:=';	';Z ,0%$(;?4	9&SS  
 
 	

 
0  
 
 	

 
* &*! U !%QATT,:TFIT !%QATT,:TFIT %) T %) TG %) O+b %) P+d29 #29 	29 29 
29j ,0	,	,$(	,		,-D -D 	-D
 -D -D "-D -Dr^   rM   c                   [        U 5      n U S   R                  nU  Vs/ s H  o"R                  R                  SS5      PM      nn[        R
                  " US[        R                  " [        U 5      [        U S   5      4SUR                  S9S9nU  Vs/ s H  o"R                  R                  SS5      PM      nn[        R
                  " US[        R                  " U[        S9S9nUR                  5       n/ n[        UR                  S   5       H)  n	U" USS2U	4   USS2U	4   S	9n
UR                  U
5        M+     U$ s  snf s  snf )
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   r   r   F)orderrc   )r   r1  rs   Nr  )listrc   rQ   r   ra   r  ru   r   r#  rS   
empty_likery   r$  r   rf   rE  )masked_arraysrc   r  rX   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs              r[   #transpose_homogeneous_masked_arraysr}  d  sB    'M!""E2?@-3ii2&-F@HH]1%5!67##
 2??#YYq"%E?~~A2==):$G ))+H/1$**1-.!"3AqD"9@PQRTUQU@VW  0 / - A @s   %E%E)rv  zSequence[BaseMaskedArray]ra  zlist[BaseMaskedArray])l
__future__r   typingr   r   r   r   r   r  numpyra   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._exceptionsr   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-   r  r.   r/   r0   pandas.core.algorithmsr1   r2   r3   r4   r5   pandas.core.array_algosr6   r7    pandas.core.array_algos.quantiler8   pandas.core.arrayliker9   pandas.core.arrays._utilsr:   pandas.core.arrays.baser;   pandas.core.constructionr<   rh  r=   r>   pandas.core.indexersr?   pandas.core.opsr@   pandas.core.util.hashingrA   collections.abcrB   rC   r  rD   r5  rF   rG   rH   rJ   pandas.compat.numpyrK   r   rM   r}  r   r^   r[   <module>r     s    "    3     . ' 4 : 2  6    @ * > 2 
 5 . / / 1 .uDh uDp/!,!!r^   