
    MhR                    T   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,J-r-J.r.J/r/J0r0J1r1  S SK2J3r3  S SK4J5r5J6r6J7r7J8r8  S SK9J:r;J<r<JrJ=r=J>r>  S SK?J@r@JArAJBrBJCrCJDrD  S SKEJFrFJGrG  S SKHJIrI  S SKJJKrK  S SKLJMrM  S SKNJOrO  S SKPJQrRJSrSJTrT  S SKUJVrV  S SKWJXrX  S SKYJZrZ  \(       a"  S SK[J\r\J]r]  S SK^J_r_  S SK`Jara  S SKJbrbJcrc  S SK`Jdrd  S SKeJfrg   " S  S!\K\O5      rh    S#S" jrig)$    )annotations)TYPE_CHECKINGAnyCallableLiteraloverloadN)libmissing)is_supported_dtype)	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSelfSequenceIndexerShapenpt)IS64is_platform_windowsAbstractMethodError)doc)validate_fillna_kwargs)ExtensionDtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker
   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexer)invalid_comparison)
hash_array)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLikeFloatingArray)functionc                  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\$ )BaseMaskedArrayk   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)rL   __new__rP   rR   )clsvaluesmaskresults       K/var/www/html/env/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copyrP   rR   )selfrW   rX   rg   s       rZ   __init__BaseMaskedArray.__init__   sw     4,,rxx1G2  <<4::%ABB[[]F99;D

r]   Nrb   rg   c               6    U R                  XUS9u  pEU " XE5      $ )Nrk   )_coerce_to_array)rV   scalarsrb   rg   rW   rX   s         rZ   _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rb   z5Default 'empty' implementation is invalid for dtype='')
r`   emptytypefillrN   onesboolr_   rb   NotImplementedError)rV   re   rb   rW   rX   rY   s         rZ   _emptyBaseMaskedArray._empty   sv     %zz2C,,-wwuD)V"&&&%<<*?%GwaP  r]   c                    [         $ rT   )str)rh   boxeds     rZ   
_formatterBaseMaskedArray._formatter   s    
r]   c                    [        U 5      erT   r   rh   s    rZ   rb   BaseMaskedArray.dtype   s    !$''r]   c                    g rT    rh   items     rZ   __getitem__BaseMaskedArray.__getitem__       r]   c                    g rT   r   r   s     rZ   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      $ rT   )r>   rR   r!   rb   na_valuerP   r[   )rh   r   newmasks      rZ   r   r      sc    "4.**T"7zz***::d##

4 0'::r]   T)limit
limit_arearg   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   rX      insideoutside)rR   anyr
   get_fill_funcr   rP   Trg   allargmaxlenr[   )rh   methodr   r   rg   rX   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                rZ   _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   rR   r
   check_value_sizer   r   r   r   rP   r   rg   r[   )
rh   valuer   r   rg   rX   r   r   r   r   s
             rZ   fillnaBaseMaskedArray.fillna   s     /u=zz((c$i@88::!,,V))D::<<66'}}H'}}HX:''

HJJ?? !%J!%aJ#(4  	 !YY[
  "!W
r]   rg   c                   [        U 5      erT   r   )rV   rW   rb   rg   s       rZ   rm    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5       SU R                    35      e)zQ
Check if we have a scalar that we can cast losslessly.

Raises
------
TypeError
bfzInvalid value 'z' for dtype )rb   kindr	   r!   
is_integeris_floatrd   r}   )rh   r   r   s      rZ   _validate_setitem_value'BaseMaskedArray._validate_setitem_value  s     zz3;{{5!! " S[~~e$$U(;(; )< ~~e$$e)<)<AQAQASAS
 /#e*\$**NOOr]   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 )NTFrr   )r>   r$   r)   rb   rR   r   rP   rm   )rh   keyr   rX   s       rZ   __setitem__BaseMaskedArray.__setitem__3  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*   rb   r   rP   r   r	   r   rx   r`   isnanrR   r   super__contains__)rh   r   	__class__s     rZ   r   BaseMaskedArray.__contains__D  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   _hasnarP   rb   r   ziprR   ranger   )rh   valr   isna_is        rZ   __iter__BaseMaskedArray.__iter__L  s     99>;;::CI &  ::.."%djj$**"=JE&!		 #> 3t9%g &s   B-B/c                ,    [        U R                  5      $ rT   )r   rP   r   s    rZ   __len__BaseMaskedArray.__len__\  s    4::r]   c                .    U R                   R                  $ rT   )rP   re   r   s    rZ   re   BaseMaskedArray.shape_  s    zzr]   c                .    U R                   R                  $ rT   )rP   r   r   s    rZ   r   BaseMaskedArray.ndimc  s    zzr]   c                    U R                   R                  X5      nU R                  R                  X5      nU R                  X45      $ rT   )rP   swapaxesrR   r[   )rh   axis1axis2datarX   s        rZ   r   BaseMaskedArray.swapaxesg  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)r`   deleterP   rR   r[   )rh   locr   r   rX   s        rZ   r   BaseMaskedArray.deletel  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      $ rT   )rP   reshaperR   r[   rh   argskwargsr   rX   s        rZ   r   BaseMaskedArray.reshapeq  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      $ rT   )rP   ravelrR   ru   r   s        rZ   r   BaseMaskedArray.ravelv  sC    zz00zz00Dz$%%r]   c                v    U R                  U R                  R                  U R                  R                  5      $ rT   )r[   rP   r   rR   r   s    rZ   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)
rb   r   nvvalidate_roundr`   roundrP   _maybe_mask_resultrR   rg   )rh   r   r   r   rW   s        rZ   r   BaseMaskedArray.round  sa    0 ::??c!K
$'$**BxB6B &&vzz/@AAr]   c                l    U R                  U R                  ) U R                  R                  5       5      $ rT   r[   rP   rR   rg   r   s    rZ   
__invert__BaseMaskedArray.__invert__  &    TZZ__->??r]   c                l    U R                  U R                  * U R                  R                  5       5      $ rT   r   r   s    rZ   __neg__BaseMaskedArray.__neg__  r   r]   c                "    U R                  5       $ rT   r   r   s    rZ   __pos__BaseMaskedArray.__pos__  s    yy{r]   c                |    U R                  [        U R                  5      U R                  R	                  5       5      $ rT   )r[   absrP   rR   rg   r   s    rZ   __abs__BaseMaskedArray.__abs__  s(    DJJ1BCCr]   c                4    [         R                  " U [        S9$ )Nrr   )r`   asarrayobjectr   s    rZ   _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   r9   r  r%   
libmissingNArf   warningscatch_warningsfilterwarningsRuntimeWarningrP   astyperR   )rh   rb   rg   r   hasnar   s         rZ   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   rb   r   )r   tolistr   rP   rb   r  r
  r  )rh   xrb   s      rZ   r  BaseMaskedArray.tolist  sb    99q=(,-1HHJ--)9)9}}5:==}AHHJJ .s   Bc                    g rT   r   rh   rb   rg   s      rZ   r  BaseMaskedArray.astype  r   r]   c                    g rT   r   r  s      rZ   r  r    r   r]   c                    g rT   r   r  s      rZ   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   Frk   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)rb   r   rg   )r&   rb   rg   r_   r'   r  r  r  r  rP   r  numpy_dtyperR   construct_array_typer    ro   r   r`   nan
datetime64r	   
no_defaultr   rf   r  )rh   rb   rg   r   rX   rV   eaclsr   s           rZ   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 R                  US9$ )zd
the array interface, return my values
We return an object array here to preserve our scalar values
rr   )r  r  s      rZ   	__array__BaseMaskedArray.__array__T  s     }}5}))r]   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   reducerr   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   )rE   rI   IntegerArrayr   r!  r   )pandas.core.arraysrE   rI   r0  rb   r   rg   r`   float16r  float32r$  )r  rE   rI   r0  mrX   s        rZ   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rT   r   ).0r  r5  s     rZ   	<genexpr>2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s     8AQs   )r  rO   )getr_   r+  rL   NotImplementedr-   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncr`   zerosr   rx   rR   appendrP   getattrnouttupler   	_na_value)rh   ufuncr   inputsr   r-  r  rY   inputs2rX   r5  s            @@rZ   __array_ufunc__BaseMaskedArray.__array_ufunc___  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)rX   ru   )pyarrowr;   rP   rR   )rh   ru   pas      rZ   __arrow_array__BaseMaskedArray.__arrow_array__  s$     	xx

$x??r]   c                6    U R                   R                  5       $ rT   )rR   r   r   s    rZ   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)rR   rg   r
  r  r#   r   r*   )rh   rX   others      rZ   _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)Nrb   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   rY  rZ  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8rx   r[  r   r!  )r\  r_  r  )r   rY  Fr   rZ  ) __name__hasattrr#   r   pd_arrayr=   r_   rL   rP   rR   r:   r`   r  r   ry   r/   maybe_prepare_scalar_for_opget_array_opr<   rc   rx   rT  r
  r  	ones_likerb   r   r  float64errstatewherer   )	rh   rS  opop_nameomaskpd_oprX   rY   rb   s	            rZ   _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   rD   r   rX  zLengths must match to comparerx   rr   r  elementwise__Fr   )r1  rE   r_   rL   rP   rR   r#   r`   r  r   ry   r   rf   r
  r  r@  re   rw   r  r  r  FutureWarningDeprecationWarningrB  rb  r<  r?   rT  )rh   rS  rk  rE   rX   rY   r   s          rZ   _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   rH   Fr   r   rD   r4  )TimedeltaArrayr   rr   r!  r0  )r_   rD  r   rb   r   r1  rI   rE   r	   is_np_dtyper   ry  ru   r[   r0  r`   r$  )	rh   rY   rX   divr_  rI   rE   ry  r0  s	            rZ   r   "BaseMaskedArray._maybe_mask_resultT  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       $ rT   )rR   rg   r   s    rZ   r*   BaseMaskedArray.isna  s    zz  r]   c                .    U R                   R                  $ rT   r  r   s    rZ   rE  BaseMaskedArray._na_value  s    zz"""r]   c                \    U R                   R                  U R                  R                  -   $ rT   )rP   nbytesrR   r   s    rZ   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   )r`   concatenaterP   rR   )rV   	to_concatr   r  r   rX   s         rZ   _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)r@   rP   hashrb   r   r*   )rh   r  r  r  hashed_arrays        rZ   _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*   rN   r4   rP   rR   r+   r`   r  r[   )	rh   indexerr  r  r   data_fill_valuerY   rX   	fill_masks	            rZ   r4   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   rD   c              3  R   >#    U  H  oTR                   R                  L v   M     g 7frT   r  )r8  r   rh   s     rZ   r9  'BaseMaskedArray.isin.<locals>.<genexpr>  s"      @6@stzz***js   $'rr   Fr   )r1  rE   r`   r  r1   rP   r   rb   r  r   rR   r@  re   rx   )rh   rW   rE   
values_arrrY   values_have_NArX   s   `      rZ   r1   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      $ rT   )rP   rg   rR   r[   )rh   r   rX   s      rZ   rg   BaseMaskedArray.copy  s3    zz zz ++r]   c                \    U R                   nU R                  n[        R                  " X!US9$ )N)keeprX   )rP   rR   algos
duplicated)rh   r  rW   rX   s       rZ   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_maskrP   rR   r[   )rh   uniquesrX   s      rZ   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   rf   r_   r:   r  r  rP   searchsorted)rh   r   r  r  s       rZ   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_sentinelrX   r   rr   r   r   )rP   rR   r0   rb   r"  r   r   r`   r@  rx   r   intpmaxinsertr[   )rh   r  arrrX   codesr  has_nasizeuniques_maskna_indexna_code
uniques_eas               rZ   	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                   $ rT   )rP   r   s    rZ   _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   )IndexrC   rz  dropnarX   rr   Tr   countF)indexnamerg   )pandasr  rC   pandas.arraysr0  r  value_counts_arraylikerP   rR   r`   r@  r   rc   rg   rb   r#  )rh   r  r  rC   r0  keysvalue_counts
na_counter
mask_indexrX   r  r  s               rZ   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  rr   )	r3   rP   rR   r`   r@  re   rc   ru   argsort)rh   r  rY   res_masks       rZ   _modeBaseMaskedArray._modeS  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)ru   rb   r`   array_equalrR   rP   r(   )rh   rS  leftrights       rZ   equalsBaseMaskedArray.equals\  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.
)rX   r  qsinterpolation   rr   rX   )r7   rP   rR   r`   r$  r   r   ry   r*   r   rw   re   rx   r"   rb   r@  r"  r   )rh   r  r  resout_masks        rZ   	_quantileBaseMaskedArray._quantilel  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  rX   r   )r   )r  r   	mask_sizer   rr   r   )rB  rP   rR   r.   popr*   _wrap_na_resultr   r`   r@  rx   r   r
  r  )
rh   r  r  r  r   rY   r   rX   rk  r   s
             rZ   _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_   r`   ra   rR   r   r   r   )rh   r  rY   r  r   rX   s         rZ   _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$ )Nrr   Float32r3  rh  )r  medianr  r  skewkurt)r  r     int32int64uint32uint64)r   r   ur   r   r  )r`   rw   rx   rb   itemsizer"  r  r   r   r   r;   r   )rh   r  r   r  rX   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              rZ   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   rr   r  r   )r_   r`   ra   r   r@  re   rx   r  )rh   r  rY   r  	min_countr   s         rZ    _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_sumr6   r  rP   rR   r  rh   r  r  r   r   rY   s         rZ   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_prodr6   r  rP   rR   r  r  s         rZ   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_meanr6   r  rP   rR   r  rh   r  r   r   rY   s        rZ   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_funcr6   r  rP   rR   r  rh   r  r   r  r   rY   s         rZ   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   r6   r  rP   rR   r  r!  s         rZ   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_minr6   r  rP   rR   r  r  s        rZ   r  BaseMaskedArray.min%  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_maxr6   r  rP   rR   r  r  s        rZ   r  BaseMaskedArray.max/  r)  r]   c                2    [        U R                  5       XS9$ )N)	na_action)r2   r  )rh   mapperr.  s      rZ   mapBaseMaskedArray.map9  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_anyrP   rg   r`   putmaskrR   _falsey_valuer   r   rb   r   rh   r  r   r   rW   rY   s         rZ   r   BaseMaskedArray.any<  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_allrP   rg   r`   r4  rR   _truthy_valuer   r   r   rb   r   r6  s         rZ   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   rX   rH   )rb   r   rP   rg   rR   r  ry   r
   interpolate_2d_inplaceru   r[   r1  rI   )rh   r   r   r  r   r>  r   rg   r   r   rX   rI   s               rZ   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  )rP   rR   rB  r5   r[   )rh   r  r  r   r   rX   rk  s          rZ   _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	aggregaterr   rank	na_option)topbottomF)r  ngroupscomp_idsrX   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsrF  get_kind_from_howrR   r   rg   r`   r@  rx   r;  _cython_op_ndim_compatrP   rG  _cython_aritytiler   r   )rh   rG  rH  r  rN  idsr   rF  r   rk  rX   rP  
res_valuesaritys                 rZ   _groupby_opBaseMaskedArray._groupby_op!  s    	<005O zz77k!))+K((7$7K&=VZZ48II"KN..JJ
#
 

 66V$$((3E''+qz:<<K66)) **:CCr]   )rP   rR   )rW   rO   rX   rQ   returnr   )F)rW   rO   rX   rQ   rg   rx   r^  None)rg   rx   r^  r   )re   r   rb   r    )r~   rx   r^  zCallable[[Any], str | None])r^  r'   )r   r   r^  r   )r   r   r^  r   )r   r   r^  z
Self | Any)
r   r   r   
int | Noner   z#Literal['inside', 'outside'] | Nonerg   rx   r^  r   )NNNT)r   r`  rg   rx   r^  r   )rb   r   rg   rx   r^  ztuple[np.ndarray, np.ndarray])r^  r_  )r^  rx   )r^  rA   )r^  int)r^  r   )r^  r   )r   )r   r   r^  r   )r   ra  )r^  rO   )rb   znpt.DTypeLike | Nonerg   rx   r   r  r^  rO   ).)rb   znpt.DTypeLikerg   rx   r^  rO   )rb   r    rg   rx   r^  r:   )rb   r   rg   rx   r^  r   )T)NN)rb   zNpDtype | Nonerg   zbool | Noner^  rO   )rF  znp.ufuncr   r}   rT   )rX   znpt.NDArray[np.bool_] | Noner^  rQ   )r^  rE   )rY   z*np.ndarray | tuple[np.ndarray, np.ndarray]rX   rO   )r  zSequence[Self]r   r   r^  r   )r  r}   r  r}   r  rx   r^  znpt.NDArray[np.uint64])r  rx   r  zScalar | Noner   r   r^  r   )rW   r   r^  rE   )r   )r  zLiteral['first', 'last', False]r^  rQ   )r  N)r   z$NumpyValueArrayLike | ExtensionArrayr  zLiteral['left', 'right']r  zNumpySorter | Noner^  znpt.NDArray[np.intp] | np.intp)r  rx   r^  z!tuple[np.ndarray, ExtensionArray])r  rx   r^  rC   )r  rx   r^  r   )r  znpt.NDArray[np.float64]r  r}   r^  rL   )r  r}   r  rx   r  rx   )r  r}   )r  rx   r  ra  r   AxisInt | None)r  rx   r   rb  )r  rx   r   rb  r  ra  )r   r   r   ra  rg   rx   r^  rI   )r  r}   r  rx   r^  rL   )
rG  r}   rH  rx   r  ra  rN  ra  rY  znpt.NDArray[np.intp])]rb  
__module____qualname____firstlineno____doc____annotations__r   r:  r5  classmethodr[   ri   ro   r   r:   rz   r   propertyrb   r   r   r   r   rm   r   r   r   r   r   re   r   r   r   r   r   r   r   r   r   r   r   r  r	   r&  r  r  r  __array_priority__r)  rI  rN  r   rT  ro  _logical_methodrv  r   r*   rE  r  r  r  r4   r1   rg   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r0  r   r   r@  rC  r\  __static_attributes____classcell__)r   s   @rZ   rL   rL   k   s    !    MM  MR (=EI	& .2 ! ! 			   	 ( (    
;  !:>* * 	*
 8* * 
*X 			NR.8GK	  B 6;'''/3'	&' '
P6"/       ,
,
,
& < <BF@@D
.
 '+>>	[#[ [ 	[
 
[z 			K  K      ,\  AE*#*2=*	* %$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]   rL   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)orderrb   )r   r-  rr   Nr  )listrb   rP   r   r`   r  rt   r   r"  rR   
empty_likerx   r#  r   re   rA  )masked_arraysrb   r  rW   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs              rZ   #transpose_homogeneous_masked_arraysrz  Q  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)rs  zSequence[BaseMaskedArray]r^  zlist[BaseMaskedArray])j
__future__r   typingr   r   r   r   r   r  numpyr`   pandas._libsr	   r
   r
  pandas._libs.tslibsr   pandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.compatr   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._validatorsr   pandas.core.dtypes.baser    pandas.core.dtypes.commonr!   r"   r#   r$   r%   r&   pandas.core.dtypes.dtypesr'   pandas.core.dtypes.missingr(   r)   r*   r+   pandas.corer,   r  r-   r.   r/   pandas.core.algorithmsr0   r1   r2   r3   r4   pandas.core.array_algosr5   r6    pandas.core.array_algos.quantiler7   pandas.core.arrayliker8   pandas.core.arrays._utilsr9   pandas.core.arrays.baser:   pandas.core.constructionr;   rd  r<   r=   pandas.core.indexersr>   pandas.core.opsr?   pandas.core.util.hashingr@   collections.abcrA   rB   r  rC   r1  rE   rF   rG   rI   pandas.compat.numpyrJ   r   rL   rz  r   r]   rZ   <module>r     s    "    3     . ' : 2  6    @ * > 2 
 5 . / / 1 .cDh cDL/!,!!r]   