+
    xȇiz                      ^ RI Ht ^ RIHtHtHtHtHtHt ^ RI	t	^ RI
t^ RIHtHt ^ RIHtHtHt ^ RIHt ^ RIHtHt ^ RIHt ^ R	IHt ^ R
IHt ^ RI H!t! ^ RI"H#t#H$t$H%t%H&t&H't'H(t( ^ RI)H*t*H+t+ ^ RI,H-t-H.t.H/t/H0t0 ^ RI1H2tH3t3HtH4t4H5t5 ^ RI6H7t7H8t8H9t9H:t:H;t; ^ RI<H=t=H>t> ^ RI?H@t@ ^ RIAHBtB ^ RICHDtD ^ RIEHFtF ^ RIGHHtH ^ RIIHJtKHLtLHMtM ^ RINHOtOHPtP ^ RIQHRtR ^ RISHTtT ]'       dI   ^ RIUHVtV ^ RIUHWtWHXtX ^ RIYHZtZ ^ RI[H\t\ ^ RI]H^t^H_t_H`t`HataHbtbHctcHdtdHeteHftfHgtgHhthHitiHjtjHktkHltl ^ R ImHntn ^ R!I[Hoto ^ R"IpHqtr  ! R# R$]D]H4      tsR% R& lttR# )'    )annotations)TYPE_CHECKINGAnyLiteralSelfcastoverloadN)	is_nan_nausing_python_scalars)algoslibmissing)is_supported_dtype)IS64is_platform_windowsAbstractMethodError)astype_is_view)ExtensionDtype)maybe_downcast_to_dtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)
ArrowDtype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)shift)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexergetitem_returns_view)invalid_comparison)
hash_array)Callable)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLike	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSequenceIndexerShapenpt)NATypeFloatingArray)functionc            
      l  a  ] tR t^zt$ RtR]R&   R]R&   ]R R l4       tRR	 R
 llt]RRRR/R R ll4       t	R R lt
]R R l4       tRR R llt]R R l4       t]R R l4       t]R R l4       tR R ltRRRRRR /R! R" lltRR# R$ llt]RR/R% R& ll4       tR' tR( R) ltR* V 3R+ lltR, R- ltR. R/ lt]R0 R1 l4       t]R2 R3 l4       tR4 R5 ltRR6 R7 lltR8 R9 ltR: R; ltRR< R= llt]R> R? l4       t RR@ RA llt!RB RC lt"RD RE lt#RF RG lt$RH RI lt%RJ RK lt&RR]'PP                  3RL RM llt)RN RO lt*]RRQ RR ll4       t+]RRS RT ll4       t+]RRU RV ll4       t+RRW RX llt+RYt,RRZ R[ llt-R\]R]&   R^ R_ lt.RR` lt/]Ra Rb l4       t0Rc Rd lt1Re t2]2t3Rf Rg lt4Rh Ri lt5Rj Rk lt6]Rl 4       t7]Rm Rn l4       t8]RRo Rp ll4       t9Rq Rr lt:RsRRtRRu^ /Rv Rw llt;Rx Ry lt<Rz R{ lt=Ru^ R|R}R~RRR RR/R R llt>RR R llt?R R lt@RR R lltARR R lltBR R ltCRR R lltDRR R lltER R ltFR R ltGRR RR/R R lltHR R ltIR tJR R ltKRR R^ Ru^ /R R lltLRR R^ Ru^ /R R lltMRR Ru^ /R R lltNRR Ru^ R^/R R lltORR Ru^ R^/R R lltPRR Ru^ /R R lltQRR Ru^ /R R lltRRR R lltS]RRPRuRP/R R ll4       tT]RuRP/R R ll4       tTRR Ru^ /R R lltT]RRPRuRP/R R ll4       tU]RuRP/R R ll4       tURR Ru^ /R R lltUR R ltVRR /R R lltWR R ltXRtYV ;tZ# )BaseMaskedArrayzZ
Base class for masked arrays (which use _data and _mask to store the data).

numpy based

np.ndarray_datanpt.NDArray[np.bool_]_maskc               $    V ^8  d   QhRRRRRR/# )   valuesrU   maskrW   returnr    )formats   "i/Users/max/.openclaw/workspace/postharvest/venv/lib/python3.14/site-packages/pandas/core/arrays/masked.py__annotate__BaseMaskedArray.__annotate__   s"       3H T     c                	H    \         P                  V 4      pWn        W#n        V# N)rT   __new__rV   rX   )clsr[   r\   results   &&& r`   _simple_newBaseMaskedArray._simple_new   s!     ((-rc   Fc               (    V ^8  d   QhRRRRRRRR/# )	rZ   r[   rU   r\   rW   copyboolr]   Noner^   )r_   s   "r`   ra   rb      s,       (=EI	rc   c                	N   \        V\        P                  4      '       d    VP                  \        P                  8X  g   \        R 4      hVP                  VP                  8w  d   \        R4      hV'       d!   VP                  4       pVP                  4       pWn	        W n
        R# )zGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shapeN)
isinstancenpndarraydtypebool_	TypeErrorshape
ValueErrorrl   rV   rX   )selfr[   r\   rl   s   &&&&r`   __init__BaseMaskedArray.__init__   sw     4,,rxx1G2  <<4::%ABB[[]F99;D

rc   rs   Nrl   c                    V ^8  d   QhRRRR/# )rZ   rl   rm   r]   r   r^   )r_   s   "r`   ra   rb      s     ! !$ !4 !rc   c               	<    V P                  WVR 7      w  rEV ! WE4      # )rs   rl   )_coerce_to_array)rg   scalarsrs   rl   r[   r\   s   &&$$  r`   _from_sequenceBaseMaskedArray._from_sequence   s$    ++Gt+L6  rc   c                   V ^8  d   QhRR/# )rZ   r]   rB   r^   )r_   s   "r`   ra   rb      s      	 rc   c                	:   \        V4      P                  4       '       d&   \        V 4      P                  WP                  R 7      # \
        P                  ! V\        R 7      p\        P                  ! VRR7      pV P                  P                  pVP                  P                  pVR9   d   VR9   g   Y4u;8X  d   R8X  d[   M V# \        \        V4      p\        VP                  V P                  P                  R 7      p\        V4      ! WRP                   4      pV# )rs   T)convert_to_nullable_dtypeiuf)r!   alltyper   rs   rq   asarrayobjectr   maybe_convert_objectskindr   rT   r   rV   numpy_dtyperX   )rx   r[   rh   lkindrkindnew_datas   &&    r`   _cast_pointwise_result&BaseMaskedArray._cast_pointwise_result   s    <:,,V::,FFF&1**6TR

!!TMetm1F31F  /62F.DJJ$:$:H &\(LL9Frc   c               $    V ^8  d   QhRRRRRR/# )rZ   rv   rM   rs   r   r]   r   r^   )r_   s   "r`   ra   rb      s!      5  D rc   c                F   \        \        V4      p\        P                  ! WP                  R7      pVP                  VP                  4       \        P                  ! V\        R7      pV ! W44      p\        WP4      '       d   W%P                  8w  d   \        RV R24      hV# )z
Create an ExtensionArray with the given shape and dtype.

See also
--------
ExtensionDtype.empty
    ExtensionDtype.empty is the 'official' public version of this API.
r   z5Default 'empty' implementation is invalid for dtype='')r   r   rq   emptyr   fill_internal_fill_valueonesrm   rp   rs   NotImplementedError)rg   rv   rs   r[   r\   rh   s   &&&   r`   _emptyBaseMaskedArray._empty   s     _e,XXe::>E../wwuD)V"&&&%<<*?%GwaP  rc   c                    V ^8  d   QhRRRR/# )rZ   boxedrm   r]   zCallable[[Any], str | None]r^   )r_   s   "r`   ra   rb      s       1L rc   c                	    \         # re   )str)rx   r   s   &&r`   
_formatterBaseMaskedArray._formatter   s    
rc   c                   V ^8  d   QhRR/# )rZ   r]   r   r^   )r_   s   "r`   ra   rb      s     ( ( (rc   c                	    \        V 4      hre   r   rx   s   &r`   rs   BaseMaskedArray.dtype   s    !$''rc   c                    V ^8  d   QhRRRR/# )rZ   itemrK   r]   r   r^   )r_   s   "r`   ra   rb      s    :::#:rc   c                	    R # re   r^   rx   r   s   &&r`   __getitem__BaseMaskedArray.__getitem__   s    7:rc   c                    V ^8  d   QhRRRR/# )rZ   r   rL   r]   r   r^   )r_   s   "r`   ra   rb      s    ===D=rc   c                	    R # re   r^   r   s   &&r`   r   r      s    :=rc   c                    V ^8  d   QhRRRR/# )rZ   r   rI   r]   z
Self | Anyr^   )r_   s   "r`   ra   rb      s       1 j rc   c                	P   \        W4      pV P                  V,          p\        V4      '       d2   V'       d   V P                  P                  # V P
                  V,          # V P                  V P
                  V,          V4      p\        W4      '       d   V P                  Vn        V# re   )	r6   rX   r   rs   na_valuerV   ri   r7   	_readonly)rx   r   newmaskrh   s   &&  r`   r   r      s~    "4.**T"7zz***::d##!!$**T"2G<++#~~Frc   limit
limit_areaTc          
     ,    V ^8  d   QhRRRRRRRRR	R
/# )rZ   methodrF   r   
int | Noner   z#Literal['inside', 'outside'] | Nonerl   rm   r]   r   r^   )r_   s   "r`   ra   rb      s>     ) ) ) 	)
 8) ) 
)rc   c               	   V P                   pVP                  4       '       Ed   \        P                  ! WP                  R 7      pV P
                  P                  pVP                  pV'       d"   VP                  4       pVP                  4       pMVe   VP                  4       pV! WrVR7       Ve   VP                  4       '       g   VP                  pV( p	V	P                  4       p
\        V	4      V	RRR1,          P                  4       ,
          ^,
          pVR8X  d8   VRV
;;; VRV
 ,          uuu% W^,           R;;; W[^,           R ,          uuu% M(VR8X  d"   W^,           V;;; WZ^,           V ,          uuu% V'       d'   V P                  VP                  VP                  4      # V # V'       d   V P                  4       pV# T pV# ))ndimN)r   r\   insideoutside)rX   anyr   get_fill_funcr   rV   Trl   r   argmaxlenri   )rx   r   r   r   rl   r\   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??J  Jrc   c               $    V ^8  d   QhRRRRRR/# )rZ   r   r   rl   rm   r]   r   r^   )r_   s   "r`   ra   rb     s!     ; ;: ;D ;D ;rc   c                   V P                   pVeN   V\        V 4      8  d>   VP                  4       V8  pVP                  4       '       d   VP	                  4       pRWE&   \
        P                  ! W\        V 4      4      pVP                  4       '       d)   V'       d   V P	                  4       pM	V R,          pWV&   V# V'       d   V P	                  4       pV# V R,          pV# )aH  
Fill NA/NaN values using the specified method.

Parameters
----------
value : scalar, array-like
    If a scalar value is passed it is used to fill all missing values.
    Alternatively, an array-like "value" can be given. It's expected
    that the array-like have the same length as 'self'.
limit : int, default None
    The maximum number of entries where NA values will be filled.
copy : bool, default True
    Whether to make a copy of the data before filling. If False, then
    the original should be modified and no new memory should be allocated.
    For ExtensionArray subclasses that cannot do this, it is at the
    author's discretion whether to ignore "copy=False" or to raise.

Returns
-------
ExtensionArray
    With NA/NaN filled.

See Also
--------
api.extensions.ExtensionArray.dropna : Return ExtensionArray without
    NA values.
api.extensions.ExtensionArray.isna : A 1-D array indicating if
    each value is missing.

Examples
--------
>>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
>>> arr.fillna(0)
<IntegerArray>
[0, 0, 2, 3, 0, 0]
Length: 6, dtype: Int64
FNNN)rX   r   cumsumr   rl   r   check_value_size)rx   valuer   rl   r\   modifyr   s   &&&&   r`   fillnaBaseMaskedArray.fillna  s    L zzT!2[[]U*Fzz||yy{$((c$i@88::!YY[
!!W
$t
 	 J  aJrc   c               $    V ^8  d   QhRRRRRR/# )rZ   rs   rE   rl   rm   r]   ztuple[np.ndarray, np.ndarray]r^   )r_   s   "r`   ra   rb   N  s$     ' '''/3'	&'rc   c               	    \        V 4      hre   r   )rg   r[   rs   rl   s   &&$$r`   r~    BaseMaskedArray._coerce_to_arrayM  s     "#&&rc   c                   V P                   P                  pVR8X  d    \        P                  ! V4      '       d   V# MVR8X  d<   \        P                  ! V4      '       g   \        P
                  ! V4      '       d   V# MP\        P                  ! V4      '       g3   \        P
                  ! V4      '       d   VP	                  4       '       d   V# \        RV: RV P                    R24      h)zQ
Check if we have a scalar that we can cast losslessly.

Raises
------
TypeError
br   zInvalid value 'z' for dtype 'r   )rs   r   r   r   
is_integeris_floatru   )rx   r   r   s   && r`   _validate_setitem_value'BaseMaskedArray._validate_setitem_valueS  s     zz3;{{5!! " S[~~e$$U(;(; )< ^^E""s||E':':u?O?O?Q?QL
 /%-

|1MNNrc   c                   V ^8  d   QhRR/# )rZ   r]   rn   r^   )r_   s   "r`   ra   rb   m  s       rc   c                	   V P                   '       d   \        R 4      h\        W4      p\        V4      '       d   \	        W P
                  4      '       d>   \        P                  ! V4      '       d   \        4       '       d   RV P                  V&   R# V P                  V4      pW P                  V&   RV P                  V&   R# V P                  W P
                  R7      w  r#W P                  V&   W0P                  V&   R# )zCannot modify read-only arrayTFNr   )r   rw   r6   r   r    rs   r   r   r
   rX   r   rV   r~   )rx   keyr   r\   s   &&& r`   __setitem__BaseMaskedArray.__setitem__m  s    >>><==!$,U$UJJ77U##IKK"&

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

3"'

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

3

3rc   c                   V ^8  d   QhRR/# rZ   r]   rm   r^   )r_   s   "r`   ra   rb     s     / /4 /rc   c                	"  < \        V4      '       d   WP                  P                  Jd   \        P                  ! V4      '       d(   \        4       '       d   V P                  P                  pMV P                  P                  P                  R 8X  df   \        P                  ! V4      '       dJ   \        \        P                  ! V P                  4      V P                  ( ,          P                  4       4      # \        \        SV `9  V4      4      # )r   )r!   rs   r   r   r   r
   rV   r   rm   rq   isnanrX   r   super__contains__)rx   r   	__class__s   &&r`   r   BaseMaskedArray.__contains__  s    99JJ$7$77||C  Y[[jj))!!&&#-#,,s2C2CRXXdjj1TZZK?DDFGGEG(-..rc   c                   V ^8  d   QhRR/# )rZ   r]   r;   r^   )r_   s   "r`   ra   rb     s      ( rc   c              #  	z  "   V P                   ^8X  d   V P                  '       g   V P                   F  pVx  K	  	  R# V P                  P                  p\        V P                  V P                  RR7       F  w  r1V'       d   Vx  K  Vx  K  	  R# \        \        V 4      4       F  pW,          x  K  	  R# 5i)   T)strictN)	r   _hasnarV   rs   r   ziprX   ranger   )rx   valr   isna_is   &    r`   __iter__BaseMaskedArray.__iter__  s     99>;;;::CI &  ::.."%djj$**T"JJE&!		 #K 3t9%g &s   #B;BB;c                   V ^8  d   QhRR/# rZ   r]   intr^   )r_   s   "r`   ra   rb     s       rc   c                	,    \        V P                  4      # re   )r   rV   r   s   &r`   __len__BaseMaskedArray.__len__  s    4::rc   c                   V ^8  d   QhRR/# )rZ   r]   rM   r^   )r_   s   "r`   ra   rb     s        u  rc   c                	.    V P                   P                  # re   )rV   rv   r   s   &r`   rv   BaseMaskedArray.shape  s    zzrc   c                   V ^8  d   QhRR/# r   r^   )r_   s   "r`   ra   rb     s      c rc   c                	.    V P                   P                  # re   )rV   r   r   s   &r`   r   BaseMaskedArray.ndim  s    zzrc   c                   V ^8  d   QhRR/# rZ   r]   r   r^   )r_   s   "r`   ra   rb     s     , , ,rc   c                	    V P                   P                  W4      pV P                  P                  W4      pV P                  W44      # re   )rV   swapaxesrX   ri   )rx   axis1axis2datar\   s   &&&  r`   r  BaseMaskedArray.swapaxes  s;    zz""50zz""50++rc   c                    V ^8  d   QhRRRR/# )rZ   axisrD   r]   r   r^   )r_   s   "r`   ra   rb     s     , , , ,rc   c                	    \         P                  ! V P                  WR 7      p\         P                  ! V P                  WR 7      pV P	                  W44      # r  )rq   deleterV   rX   ri   )rx   locr  r
  r\   s   &&&  r`   r  BaseMaskedArray.delete  s;    yyS4yyS4++rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     , ,$ ,rc   c                	    V P                   P                  ! V/ VB pV P                  P                  ! V/ VB pV P                  W44      # re   )rV   reshaperX   ri   rx   argskwargsr
  r\   s   &*,  r`   r  BaseMaskedArray.reshape  sE    zz!!4262zz!!4262++rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     & & &rc   c                	    V P                   P                  ! V/ VB pV P                  P                  ! V/ VB p\        V 4      ! W44      # re   )rV   ravelrX   r   r  s   &*,  r`   r  BaseMaskedArray.ravel  sC    zz00zz00Dz$%%rc   c                    V ^8  d   QhRRRR/# )rZ   periodsr   r]   r   r^   )r_   s   "r`   ra   rb     s     	. 	.S 	.$ 	.rc   c                	    ^ pVf0   \        V P                  W^ 4      p\        V P                  WR4      pM.\        V P                  WV4      p\        V P                  WR4      p\        V 4      ! WE4      # )r   TF)r/   rV   rX   r   )rx   r   
fill_valuer  r   r   s   &&&   r`   r/   BaseMaskedArray.shift  sd    TZZ:HTZZ=HTZZ
CHTZZ>HDz(--rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     < <4 <rc   c                	v    V P                  V P                  P                  V P                  P                  4      # re   )ri   rV   r   rX   r   s   &r`   r   BaseMaskedArray.T  s%    

djjll;;rc   c                   V ^8  d   QhRR/# )rZ   decimalsr   r^   )r_   s   "r`   ra   rb     s     B Bc Brc   c                    V P                   P                  R8X  d   V # \        P                  ! W#4       \        P
                  ! V P                  3RV/VB pV P                  W@P                  P                  4       4      # )a[  
Round each value in the array a to the given number of decimals.

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

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

See Also
--------
numpy.around : Round values of an np.array.
DataFrame.round : Round values of a DataFrame.
Series.round : Round values of a Series.
r   r(  )
rs   r   nvvalidate_roundrq   roundrV   _maybe_mask_resultrX   rl   )rx   r(  r  r  r[   s   &&*, r`   r,  BaseMaskedArray.round  sa    0 ::??c!K
$'$**BxB6B &&vzz/@AArc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     @ @D @rc   c                	l    V P                  V P                  ( V P                  P                  4       4      # re   ri   rV   rX   rl   r   s   &r`   
__invert__BaseMaskedArray.__invert__  &    TZZ__->??rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     @ @ @rc   c                	l    V P                  V P                  ) V P                  P                  4       4      # re   r1  r   s   &r`   __neg__BaseMaskedArray.__neg__  r4  rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s       rc   c                	"    V P                  4       # re   rl   r   s   &r`   __pos__BaseMaskedArray.__pos__  s    yy{rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     D D Drc   c                	|    V P                  \        V P                  4      V P                  P	                  4       4      # re   )ri   absrV   rX   rl   r   s   &r`   __abs__BaseMaskedArray.__abs__  s(    DJJ1BCCrc   c                   V ^8  d   QhRR/# rZ   r]   rU   r^   )r_   s   "r`   ra   rb     s     . .* .rc   c                	:    \         P                  ! V \        R 7      # )r   )rq   r   r   r   s   &r`   _values_for_json BaseMaskedArray._values_for_json  s    zz$f--rc   c               (    V ^8  d   QhRRRRRRRR/# )	rZ   rs   znpt.DTypeLike | Nonerl   rm   r   r   r]   rU   r^   )r_   s   "r`   ra   rb      s8     ^ ^#^ ^ 	^
 
^rc   c                   V P                   p\        WW44      w  rVf   \        P                  ! \        4      pV'       d   V\        P                  ! \        4      8w  d5   \        V4      '       g$   V\        P                  J d   \        RV R24      h\        P                  ! 4       ;_uu_ 4        \        P                  ! R\        R7       V P                  P                  V4      pRRR4       VXV P                  &   V# \        P                  ! 4       ;_uu_ 4        \        P                  ! R\        R7       V P                  P                  WR7      pRRR4       V P                   '       dF   V'       g>   \#        V P                  V4      '       d"   XP%                  4       pRVP&                  n        X#   + '       g   i     L; i  + '       g   i     L|; i)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;  F)r   r1   rq   rs   r   r   
libmissingNArw   warningscatch_warningsfilterwarningsRuntimeWarningrV   astyperX   r   r   viewflags	writeable)rx   rs   rl   r   hasnar
  s   &&&&  r`   to_numpyBaseMaskedArray.to_numpy   sQ   D 24P=HHV$E&))'..
- )% 1& &  ((**''>Jzz((/ +  (D  ((**''>Jzz(((: + ~~~d~djj%/P/Pyy{',

$ +*
 +*s   18F99G9G		G	c                   V ^8  d   QhRR/# )rZ   r]   listr^   )r_   s   "r`   ra   rb   `  s     K K Krc   c                   V P                   ^8  d    V  Uu. uF  qP                  4       NK  	  up# V P                  '       d   RMV P                  P                  pV P                  V\        P                  R7      P                  4       # u upi )a  
Return a list of the values.

These are each a scalar type, which is a Python scalar
(for str, int, float) or a pandas scalar
(for Timestamp/Timedelta/Interval/Period)

Returns
-------
list
    Python list of values in array.

See Also
--------
Index.to_list: Return a list of the values in the Index.
Series.to_list: Return a list of the values in the Series.

Examples
--------
>>> arr = pd.array([1, 2, 3])
>>> arr.tolist()
[1, 2, 3]
Nrs   r   )r   tolistr   rV   rs   rX  rM  rN  )rx   xrs   s   &  r`   r^  BaseMaskedArray.tolist`  sf    0 99q=(,-1HHJ--)9)9}}5:==}AHHJJ .s   B
.c               $    V ^8  d   QhRRRRRR/# )rZ   rs   znpt.DTypeLikerl   rm   r]   rU   r^   )r_   s   "r`   ra   rb   ~  s    OOMOO
Orc   c                	    R # re   r^   rx   rs   rl   s   &&&r`   rS  BaseMaskedArray.astype}  s    LOrc   c               $    V ^8  d   QhRRRRRR/# )rZ   rs   r   rl   rm   r]   r2   r^   )r_   s   "r`   ra   rb     s    TTNT$TTrc   c                	    R # re   r^   rc  s   &&&r`   rS  rd    s    QTrc   c               $    V ^8  d   QhRRRRRR/# rZ   rs   rC   rl   rm   r]   rB   r^   )r_   s   "r`   ra   rb     s    JJIJTJIJrc   c                	    R # re   r^   rc  s   &&&r`   rS  rd    s    GJrc   c               $    V ^8  d   QhRRRRRR/# rh  r^   )r_   s   "r`   ra   rb     s!     , ,I ,T ,Y ,rc   c                	:   \        V4      pWP                  8X  d   V'       d   V P                  4       # V # \        V\        4      '       d   \
        P                  ! 4       ;_uu_ 4        \
        P                  ! R \        R7       V P                  P                  VP                  VR7      pRRR4       XV P                  J d   V P                  MV P                  P                  4       pVP                  4       pV! W4RR7      # \        V\        4      '       d$   VP                  4       pVP                  WVR7      # VP                   R8X  d   \"        P$                  pM8VP                   R8X  d   \"        P&                  ! R4      pM\(        P*                  pVP                   R	9   d   V P,                  '       d   \/        R
4      hVP                   R8X  d   V P,                  '       d   \/        R4      hV P1                  WVR7      pV#   + '       g   i     ELe; i)rJ  rK  r;  NFr}   r   MNaTr   zcannot convert NA to integerr   z cannot convert float NaN to bool)rs   r   rl   )r   rs   rl   rp   r   rO  rP  rQ  rR  rV   rS  r   rX   construct_array_typer   r   r   rq   nan
datetime64r   
no_defaultr   rw   rX  )rx   rs   rl   r
  r\   rg   eaclsr   s   &&&     r`   rS  rd    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   )AH		H	i  c               $    V ^8  d   QhRRRRRR/# )rZ   rs   zNpDtype | Nonerl   zbool | Noner]   rU   r^   )r_   s   "r`   ra   rb     s$     5 5#52=5	5rc   c                &   VRJ du   V P                   '       gX   \        P                  ! V P                  WR7      pV P                  '       d"   VP                  4       pRVP                  n        V# \        R4      hVf   RpV P                  WR7      # )zd
the array interface, return my values
We return an object array here to preserve our scalar values
Fr}   z:Unable to avoid copy while creating an array as requested.)
r   rq   r3   rV   r   rT  rU  rV  rw   rX  )rx   rs   rl   rh   s   &&& r`   	__array__BaseMaskedArray.__array__  sz     5=;;;$**EE>>>#[[]F-2FLL*L  <D}}5}44rc   ztuple[type, ...]_HANDLED_TYPESc                    V ^8  d   QhRRRR/# )rZ   ufuncznp.ufuncr   r   r^   )r_   s   "r`   ra   rb     s     M' M'X M's M'rc   c                	  a	a
 VP                  R R4      pW5,            F0  p\        V. V P                  O\        N54      '       d   K*  \        u # 	  \
        P                  ! WV.VO5/ VB pV\        Jd   V# R V9   d   \
        P                  ! WV.VO5/ VB # VR8X  d(   \
        P                  ! WV.VO5/ VB pV\        Jd   V# \        P                  ! \        V 4      \        R7      o	. pV FZ  p\        V\        4      '       d1   S	VP                  ,          o	VP                  VP                  4       KI  VP                  V4       K\  	  R V	3R llo
\!        W4      ! V/ VB pVP"                  ^8  d3   \$        ;QJ d    . V
3R lV 4       F  NK  	  5# ! V
3R lV 4       4      # VR8X  d/   V P                  P'                  4       '       d   V P(                  # V# S
! V4      # )outreducer   c                   V ^8  d   QhRR/# )rZ   r_  rU   r^   )r_   s   "r`   ra   5BaseMaskedArray.__array_ufunc__.<locals>.__annotate__  s     	 	: 	rc   c                B  < ^ RI HpHpHp V P                  P
                  R8X  d   SP                  4       pV! W4      # V P                  P
                  R9   d   SP                  4       pV! W4      # V P                  P
                  R8X  d   SP                  4       pV P                  \        P                  8X  d    V P                  \        P                  4      p \        4       '       d   RV\        P                  ! V 4      &   V! W4      # \        P                  V S&   V # )r   )r?   rQ   IntegerArrayr   r   r   T)pandas.core.arraysr?   rQ   r  rs   r   rl   rq   float16rS  float32r
   r   ro  )r_  r?   rQ   r  mr\   s   &    r`   reconstruct4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s      ww||s"IIK#A))%IIK#A))$IIK77bjj( ,A;;%)AbhhqkN$Q**&&$Hrc   c              3  4   <"   T F  pS! V4      x  K  	  R # 5ire   r^   ).0r_  r  s   & r`   	<genexpr>2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s     8AQs   r^   )getrp   rw  rT   NotImplementedr$   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncrq   zerosr   rm   rX   appendrV   getattrnouttupler   	_na_value)rx   ry  r   inputsr  r{  r_  rh   inputs2r\   r  s   &&&*,    @@r`   __array_ufunc__BaseMaskedArray.__array_ufunc__  s    jj#Aa!H4#6#6!H!HII%% 
 <<
"(
,2
 'MF?44V&,06  X77V&,06F ^+xxD	.A!_--qww'q! 	 	8 ';F;::>5885858888xzz~~~~%Mv&&rc   c                Z    ^ RI pVP                  V P                  V P                  VR7      # )z&
Convert myself into a pyarrow Array.
N)r\   r   )pyarrowr3   rV   rX   )rx   r   pas   && r`   __arrow_array__BaseMaskedArray.__arrow_array__  s$     	xx

$x??rc   c                   V ^8  d   QhRR/# r   r^   )r_   s   "r`   ra   rb   (  s     & & &rc   c                	H    \        V P                  P                  4       4      # re   )rm   rX   r   r   s   &r`   r   BaseMaskedArray._hasna'  s     DJJNN$%%rc   c                    V ^8  d   QhRRRR/# )rZ   r\   znpt.NDArray[np.bool_] | Noner]   rW   r^   )r_   s   "r`   ra   rb   /  s      0	rc   c                	"   Vfx   V P                   P                  4       pV\        P                  J d   VR,          pV# \	        V4      '       d,   \        V4      \        V4      8X  d   V\        V4      ,          pV# V P                   V,          pV# NT)rX   rl   rM  rN  r   r   r!   )rx   r\   others   &&&r`   _propagate_maskBaseMaskedArray._propagate_mask/  s{     <::??$D
%d{
 	 e$$Us4y)@d5k)  ::$Drc   c                	   VP                   pR p\        VR4      '       gC   \        V4      '       d2   \        V4      \        V 4      8X  d   \	        V4      p\        VRR7      p\        V\        4      '       d   VP                  VP                  rAMY\        V4      '       dI   \        V\        4      '       g   \        P                  ! V4      pVP                  ^8  d   \        R4      h\        P                   ! V\        V 4      34      p\        P"                  ! V4      p\%        V4      p\        V\        4      '       d'   \        VP&                  \(        4      '       d   \*        # VR9   d,   \        V\        P,                  4      '       d   \/        V4      pV P1                  WA4      pV\2        P4                  J d   \        P6                  ! V P                  4      pV P&                  P8                  R8X  d5   VR9   d   \        R	V R
24      hVR9   d   RpMRpVP;                  V4      pMRV9   d<   V P&                  P8                  R8w  d!   VP;                  \        P<                  4      pMVR9   d#   V P?                  Wv4      p	WPA                  4       3# M_V P&                  P8                  R9   d
   VR9   d   Tp\        PB                  ! RR7      ;_uu_ 4        V! V P                  V4      pR R R 4       VR8X  d   \        PD                  ! V P                  ^8H  V P                  ( ,          RV4      pVe%   \        PD                  ! V^ 8H  V( ,          RV4      pMV\2        P4                  Jd   \        PD                  ! V^ 8H  RV4      pMVR8X  d   Ve%   \        PD                  ! V^8H  V( ,          RV4      pM/V\2        P4                  Jd   \        PD                  ! V^8H  RV4      p\        PD                  ! V P                  ^ 8H  V P                  ( ,          RV4      pV P?                  XV4      #   + '       g   i     ELN; i)Nrs   T)extract_numpy(can only perform ops with 1-d structurespowrpowr   truedivz
operator 'z!' not implemented for bool dtypesint8rm   r   r   rJ  )r   F>   r  r  >   r  r  r  floordivrtruediv	rfloordiv>   modrmod>   divmodrdivmod)r  r  )#__name__hasattrr   r   pd_arrayr5   rp   rT   rV   rX   r2   rq   r   r   r   r&   maybe_prepare_scalar_for_opget_array_opr4   rs   r   r  rt   rm   r  rM  rN  	ones_liker   rS  float64r-  rl   errstatewhere)
rx   r  opop_nameomaskpd_opr\   rh   rs   ress
   &&&       r`   _arith_methodBaseMaskedArray._arith_method=  sO   ++ w''U##E
c$i' UOE!%t<Ee_-- ;;5%  e^44

5)zzA~)*TUU //D	|D  $.u5e^,,EKK1T1T!!o%*UBHH*E*E KE##E1JMM!\\$**-Fzz#%   .$WI-NO  o-"E"Eu-g%$**//S*@  rzz211--f;HHJ& 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   P66Q	c                   V ^8  d   QhRR/# )rZ   r]   r?   r^   )r_   s   "r`   ra   rb     s     *6 *6 *6rc   c                	@   ^ RI Hp Rp\        V\        4      '       d'   \        VP                  \
        4      '       d   \        # \        V\        4      '       d   VP                  VP                  rAMg\        V4      '       dW   \        P                  ! V4      pVP                  ^8  d   \        R4      h\        V 4      \        V4      8w  d   \!        R4      hV\"        P$                  J dZ   \        P&                  ! V P                  P(                  RR7      p\        P*                  ! V P                  P(                  RR7      pM\,        P.                  ! 4       ;_uu_ 4        \,        P0                  ! RR\2        4       \,        P0                  ! RR\4        4       \7        V P                  R	VP8                   R	24      pV! V4      pV\        J d   \;        V P                  W4      pRRR4       V P=                  WA4      pV! XVR
R7      #   + '       g   i     L,; i)r   r>   Nr  zLengths must match to comparerm   r   rJ  elementwise__Fr;  )r  r?   rp   r2   rs   r   r  rT   rV   rX   r   rq   r   r   r   r   rw   rM  rN  r  rv   r   rO  rP  rQ  FutureWarningDeprecationWarningr  r  r8   r  )rx   r  r  r?   r\   rh   r   s   &&&    r`   _cmp_methodBaseMaskedArray._cmp_method  sz   3e^,,EKK1T1T!!//++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HH	c                    V ^8  d   QhRRRR/# )rZ   rh   z*np.ndarray | tuple[np.ndarray, np.ndarray]r\   rU   r^   )r_   s   "r`   ra   rb     s     3 3@3HR3rc   c                |   \        V\        4      '       d'   Vw  r4V P                  W24      V P                  WB4      3# VP                  P                  R8X  d:   ^ RIHp \        4       '       d   RV\        P                  ! V4      &   V! WRR7      # VP                  P                  R8X  d   ^ RIH
p V! WRR7      # \        P                  ! VP                  R4      '       dn   \        VP                  4      '       dS   ^ R	IHp VP                  P                  R
4      W&   \        W4      '       g   VP!                  WP                  R7      # V# VP                  P                  R9   d   ^ RIHp V! WRR7      # VP                  \$        8X  d   V P                  P&                  W&   V# \        P(                  W&   V# )zW
Parameters
----------
result : array-like or tuple[array-like]
mask : array-like bool
r   rP   TFr;  r   r>   r  )TimedeltaArrayrm  r   r   r  )rp   r  r-  rs   r   r  rQ   r
   rq   r   r?   r   is_np_dtyper   r  r   ri   r  r   r   ro  )	rx   rh   r\   divr  rQ   r?   r  r  s	   &&&      r`   r-  "BaseMaskedArray._maybe_mask_result  sW    fe$$HC''2''2 
 <<#8{{)-RXXf%& 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\\V#::..FLM66FLMrc   c                   V ^8  d   QhRR/# rD  r^   )r_   s   "r`   ra   rb     s     ! !j !rc   c                	6    V P                   P                  4       # re   )rX   rl   r   s   &r`   r!   BaseMaskedArray.isna  s    zz  rc   c                	.    V P                   P                  # re   r]  r   s   &r`   r  BaseMaskedArray._na_value  s    zz"""rc   c                   V ^8  d   QhRR/# r   r^   )r_   s   "r`   ra   rb     s     5 5 5rc   c                	d    V P                   P                  V P                  P                  ,           # re   )rV   nbytesrX   r   s   &r`   r  BaseMaskedArray.nbytes  s!    zz  4::#4#444rc   c               $    V ^8  d   QhRRRRRR/# )rZ   	to_concatzSequence[Self]r  rD   r]   r   r^   )r_   s   "r`   ra   rb     s(      !  
	rc   c                	    \         P                  ! V Uu. uF  q3P                  NK  	  upVR 7      p\         P                  ! V Uu. uF  q3P                  NK  	  upVR 7      pV ! WE4      # u upi u upi r  )rq   concatenaterV   rX   )rg   r  r  r_  r
  r\   s   &&&   r`   _concat_same_type!BaseMaskedArray._concat_same_type  sX     ~~	:	1ww	:F~~	:	1ww	:F4 ;:s   A+A0c               (    V ^8  d   QhRRRRRRRR/# )rZ   encodingr   hash_key
categorizerm   r]   znpt.NDArray[np.uint64]r^   )r_   s   "r`   ra   rb     s,      *-;?	rc   c               	    \        V P                  WVR 7      p\        V P                  P                  4      W@P                  4       &   V# ))r  r  r  )r9   rV   hashrs   r   r!   )rx   r  r  r  hashed_arrays   &$$$ r`   _hash_pandas_object#BaseMaskedArray._hash_pandas_object  s>     "JJ
 %))<)<$=YY[!rc   
allow_fillr"  r  c               (    V ^8  d   QhRRRRRRRR/# )	rZ   r  rm   r"  zScalar | Noner  rD   r]   r   r^   )r_   s   "r`   ra   rb   #  s4     ". ". 	".
 "". ". 
".rc   c               	X   \        V4      '       d   V P                  P                  MTp\        V P                  VVVVR 7      p\        V P
                  VRW$R 7      pV'       d7   \        V4      '       d&   \        P                  ! V4      R8H  pW6V&   Wx,          pV P                  Wg4      # ))r"  r  r  Tr   )
r!   rs   r   r+   rV   rX   r"   rq   r   ri   )	rx   indexerr  r"  r  data_fill_valuerh   r\   	fill_masks	   &&$$$    r`   r+   BaseMaskedArray.take#  s     04J/?/?DJJ++Z 	 JJ&!
 JJDZ
 %
++

7+r1I *9#D--rc   c                    V ^8  d   QhRRRR/# )rZ   r[   rB   r]   r?   r^   )r_   s   "r`   ra   rb   I  s     6 69 6 6rc   c                	  a  ^ RI Hp \        P                  ! V4      p\	        S P
                  V4      pS P                  '       dd   VP                  \        8H  ;'       d;    \        ;QJ d    V 3R lV 4       F  '       g   K   RM	  RM! V 3R lV 4       4      pWTS P                  &   \        P                  ! S P
                  P                  \        R7      pV! WFRR7      # )r   r>   c              3  R   <"   T F  qSP                   P                  J x  K  	  R # 5ire   r]  )r  r   rx   s   & r`   r  'BaseMaskedArray.isin.<locals>.<genexpr>R  s"      @6@stzz***js   $'TFr   r;  )r  r?   rq   r   r(   rV   r   rs   r   r   rX   r  rv   rm   )rx   r[   r?   
values_arrrh   values_have_NAr\   s   f&     r`   r(   BaseMaskedArray.isinI  s    3 ZZ'
djj*-;;;'--7  CC @6@@CCC @6@@ =N "04::xx

((5Fu55rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb   ]  s     , ,d ,rc   c                	    V P                   P                  4       pV P                  P                  4       pV P                  W4      # re   )rV   rl   rX   ri   )rx   r
  r\   s   &  r`   rl   BaseMaskedArray.copy]  s3    zz zz ++rc   r   average	na_optionkeep	ascendingpctc          
     ,    V ^8  d   QhRRRRRRRRRR/# )	rZ   r  rD   r   r   r  r  rm   r  r^   )r_   s   "r`   ra   rb   b  s>     )0 )0 )0 	)0
 )0 )0 )0rc   c          
     	>   V^ 8w  g   V P                   ^8w  d   \        h^ RIHp V P                  pVP
                  P                  R8X  d   VP                  R4      p\        P                  ! VRVVVVV P                  4       R7      pVR9   d(   \        P                  ! V P                  \        R7      p	MV P                  P!                  4       p	VR8w  d@   V'       g8   VR9  d   ^ WP                  &   TP#                  RRR	7      p^ R
IHp
 V
! WR7      # V! WR7      # )r   rP   r   uint8F)is_datetimeliketies_methodr  r  r  r\   r   r  uint64r;  r  r\   topbottom)r   r   r  rQ   rV   rs   r   rT  libalgosrank_1dr!   rq   r  rv   rm   rX   rl   rS  r  )rx   r  r   r  r  r  rQ   r
  rh   r\   r  s   &$$$$$     r`   _rankBaseMaskedArray._rankb  s     19		Q%%4zz::??c!99W%D!!!
 ))88DJJd3D::??$DYs 11%&zz"]]8%]8F722V//rc   c                    V ^8  d   QhRRRR/# )rZ   r   zLiteral['first', 'last', False]r]   rW   r^   )r_   s   "r`   ra   rb     s     !> !>3!>	!>rc   c                b    V P                   pV P                  p\        P                  ! W!VR7      # )a  
Return boolean ndarray denoting duplicate values.

Parameters
----------
keep : {'first', 'last', False}, default 'first'
    - ``first`` : Mark duplicates as ``True`` except for the first occurrence.
    - ``last`` : Mark duplicates as ``True`` except for the last occurrence.
    - False : Mark all duplicates as ``True``.

Returns
-------
ndarray[bool]
    With true in indices where elements are duplicated and false otherwise.

See Also
--------
DataFrame.duplicated : Return boolean Series denoting
    duplicate rows.
Series.duplicated : Indicate duplicate Series values.
api.extensions.ExtensionArray.unique : Compute the ExtensionArray
    of unique values.

Examples
--------
>>> pd.array([1, 1, 2, 3, 3], dtype="Int64").duplicated()
array([False,  True, False, False,  True])
)r   r\   )rV   rX   r   
duplicated)rx   r   r[   r\   s   &&  r`   r  BaseMaskedArray.duplicated  s)    > zz==rc   c                   V ^8  d   QhRR/# r  r^   )r_   s   "r`   ra   rb     s     	/ 	/ 	/rc   c                ~    \         P                  ! V P                  V P                  4      w  rV P	                  W4      # )zZ
Compute the BaseMaskedArray of unique values.

Returns
-------
uniques : BaseMaskedArray
)r   unique_with_maskrV   rX   ri   )rx   uniquesr\   s   &  r`   uniqueBaseMaskedArray.unique  s1     ..tzz4::F..rc   c               (    V ^8  d   QhRRRRRRRR/# )	rZ   r   z$NumpyValueArrayLike | ExtensionArraysidezLiteral['left', 'right']sorterzNumpySorter | Noner]   znpt.NDArray[np.intp] | np.intpr^   )r_   s   "r`   ra   rb     s8     :H :H3:H ':H #	:H
 
(:Hrc   c                    V P                   '       d   \        R4      h\        V\        4      '       d   VP	                  \
        4      pV P                  P                  WVR7      # )a  
Find indices where elements should be inserted to maintain order.

Find the indices into a sorted array `self` (a) such that, if the
corresponding elements in `value` were inserted before the indices,
the order of `self` would be preserved.

Assuming that `self` is sorted:

======  ================================
`side`  returned index `i` satisfies
======  ================================
left    ``self[i-1] < value <= self[i]``
right   ``self[i-1] <= value < self[i]``
======  ================================

Parameters
----------
value : array-like, list or scalar
    Value(s) to insert into `self`.
side : {'left', 'right'}, optional
    If 'left', the index of the first suitable location found is given.
    If 'right', return the last such index.  If there is no suitable
    index, return either 0 or N (where N is the length of `self`).
sorter : 1-D array-like, optional
    Optional array of integer indices that sort array a into ascending
    order. They are typically the result of argsort.

Returns
-------
array of ints or int
    If value is array-like, array of insertion points.
    If value is scalar, a single integer.

See Also
--------
numpy.searchsorted : Similar method from NumPy.

Examples
--------
>>> arr = pd.array([1, 2, 3, 5])
>>> arr.searchsorted([4])
array([3])
zOsearchsorted requires array to be sorted, which is impossible with NAs present.)r  r  )r   rw   rp   r2   rS  r   rV   searchsorted)rx   r   r  r  s   &&&&r`   r  BaseMaskedArray.searchsorted  sW    d ;;;$  e^,,LL(Ezz&&u&GGrc   c                    V ^8  d   QhRRRR/# )rZ   use_na_sentinelrm   r]   z!tuple[np.ndarray, ExtensionArray]r^   )r_   s   "r`   ra   rb     s"     N! N!N! 
+N!rc   c                   V P                   pV P                  p\        VRVR7      w  rEVP                  V P                  P                  8X  g   Q VP                  V P                  34       hVP                  4       pV'       g	   V'       g   \        V4      pM\        V4      ^,           p\        P                  ! V\        R7      pV'       g   V'       d   VP                  4       p	V	^ 8X  d   \        P                  ! ^ 4      p
MVRV	 P                  4       ^,           p
WDV
8  ;;,          ^,          uu&   WVR8H  &   \        P                  ! WZ^ 4      pRW&   V P                  WX4      pWK3# )aL  
Encode the extension array as an enumerated type.

Parameters
----------
use_na_sentinel : bool, default True
    If True, the sentinel -1 will be used for NaN values. If False,
    NaN values will be encoded as non-negative integers and will not drop the
    NaN from the uniques of the values.

Returns
-------
codes : ndarray
    An integer NumPy array that's an indexer into the original
    ExtensionArray.
uniques : ExtensionArray
    An ExtensionArray containing the unique values of `self`.

    .. note::

       uniques will *not* contain an entry for the NA value of
       the ExtensionArray if there are any missing values present
       in `self`.

See Also
--------
factorize : Top-level factorize method that dispatches here.

Notes
-----
:meth:`pandas.factorize` offers a `sort` keyword as well.

Examples
--------
>>> idx1 = pd.PeriodIndex(
...     ["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"],
...     freq="M",
... )
>>> arr, idx = idx1.factorize()
>>> arr
array([0, 0, 1, 1, 2, 2])
>>> idx
PeriodIndex(['2014-01', '2014-02', '2014-03'], dtype='period[M]')
T)r"  r\   r   Nr   )rV   rX   r'   rs   r   r   r   rq   r  rm   r   intpmaxinsertri   )rx   r"  arrr\   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<
  rc   c                   V ^8  d   QhRR/# rD  r^   )r_   s   "r`   ra   rb   G  s        Z  rc   c                    V P                   # )a/  
Return values for sorting.

Returns
-------
ndarray
    The transformed values should maintain the ordering between values
    within the array.

See Also
--------
ExtensionArray.argsort : Return the indices that would sort this array.

Notes
-----
The caller is responsible for *not* modifying these values in-place, so
it is safe for implementers to give views on ``self``.

Functions that use this (e.g. ``ExtensionArray.argsort``) should ignore
entries with missing values in the original array (according to
``self.isna()``). This means that the corresponding entries in the returned
array don't need to be modified to sort correctly.

Examples
--------
In most cases, this is the underlying Numpy array of the ``ExtensionArray``:

>>> arr = pd.array([1, 2, 3])
>>> arr._values_for_argsort()
array([1, 2, 3])
)rV   r   s   &r`   _values_for_argsort#BaseMaskedArray._values_for_argsortG  s    @ zzrc   c                    V ^8  d   QhRRRR/# )rZ   dropnarm   r]   r=   r^   )r_   s   "r`   ra   rb   i  s     (B (B4 (B6 (Brc   c                   ^ RI HpHp ^ RIHp \
        P                  ! V P                  WP                  R7      w  rVp\        P                  ! \        V4      3\        P                  R7      pVP                  4       p	V^ 8  d   RVR
&   V! Wi4      p
V! V P                  P                  4       ! VV4      RR7      pV! WRRR	7      # )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
)Indexr=   r  r6  r\   r   TFr;  count)indexnamerl   r   )pandasr8  r=   pandas.arraysr  r   value_counts_arraylikerV   rX   rq   r  r   rt   rl   rs   rn  )rx   r6  r8  r=   r  keysvalue_counts
na_counter
mask_indexr\   r'  r;  s   &&          r`   rA  BaseMaskedArray.value_countsi  s    "	
 	/).)E)EJJvJJ*
&J XXs<02"((C
 >!JrN<.JJ++- 
 cW5AArc   c                    V ^8  d   QhRRRR/# )rZ   r6  rm   r]   r   r^   )r_   s   "r`   ra   rb     s     ( (D (D (rc   c                	    \        V P                  WP                  R 7      w  r#\        V 4      ! W#4      pW"P	                  4       ,          # )r9  )r*   rV   rX   r   argsort)rx   r6  rh   res_masks   &&  r`   _modeBaseMaskedArray._mode  s7    

6

KdF-nn&''rc   c                   V ^8  d   QhRR/# r   r^   )r_   s   "r`   ra   rb     s     0P 0Pt 0Prc   c                l   \        V 4      \        V4      8w  d   R# VP                  V P                  8w  d   R# \        P                  ! V P                  VP                  4      '       g   R# V P
                  V P                  ( ,          pVP
                  VP                  ( ,          p\        W#RRR7      # )a  
Return if another array is equivalent to this array.

Equivalent means that both arrays have the same shape and dtype, and
all values compare equal. Missing values in the same location are
considered equal (in contrast with normal equality).

Parameters
----------
other : ExtensionArray
    Array to compare to this Array.

Returns
-------
boolean
    Whether the arrays are equivalent.

See Also
--------
numpy.array_equal : Equivalent method for numpy array.
Series.equals : Equivalent method for Series.
DataFrame.equals : Equivalent method for DataFrame.

Examples
--------
>>> arr1 = pd.array([1, 2, np.nan])
>>> arr2 = pd.array([1, 2, np.nan])
>>> arr1.equals(arr2)
True

>>> arr1 = pd.array([1, 3, np.nan])
>>> arr2 = pd.array([1, 2, np.nan])
>>> arr1.equals(arr2)
False
FT)
strict_nandtype_equal)r   rs   rq   array_equalrX   rV   r   )rx   r  leftrights   &&  r`   equalsBaseMaskedArray.equals  s    H :e$;;$**$ ~~djj%++66zz4::+&U[[L)$OOrc   c               $    V ^8  d   QhRRRRRR/# )rZ   qsznpt.NDArray[np.float64]interpolationr   r]   rT   r^   )r_   s   "r`   ra   rb     s$     '; ';)';:=';	';rc   c                   \        V P                  V P                  \        P                  VVR7      pV P
                  '       d   V P                  ^8X  d   \        hV P                  4       P                  4       '       dy   \        P                  ! VP                  \        R7      p\        V P                  4      '       d7   \        P                  ! VP                  V P                  P                   R7      pMM\        P                  ! VP                  \        R7      pM&\        P                  ! VP                  \        R7      pV P#                  W4R7      # )z
Dispatch to quantile_with_mask, needed because we do not have
_from_factorized.

Notes
-----
We assume that all impacted cases are 1D-only.
)r\   r"  rU  rV  r   r	  )r.   rV   rX   rq   ro  r   r   r   r!   r   r   rv   rm   r   rs   r  r   r-  )rx   rU  rV  r  out_masks   &&&  r`   	_quantileBaseMaskedArray._quantile  s     !JJ vv'
 ;;; yyA~ *)yy{  77399D9#DJJ// ((399DJJ4J4JKC88CIIT:xx		6H&&s&::rc   skipnakeepdimsc               $    V ^8  d   QhRRRRRR/# )rZ   r<  r   r[  rm   r\  r^   )r_   s   "r`   ra   rb     s$      $(;?rc   c          	     	<   VR9   d   \        W4      ! R	RV/VB pMLV P                  pV P                  p\        \        RV 24      pVP	                  RR4      p	V! V3RV	RVRV/VB pV'       d   \        V4      '       d   V P                  V^ R
R7      # \        4       '       d   \        P                  ! V.4      pMVP                  ^4      p\        P                  ! ^\        R7      pV P                  WW4      # \        V4      '       d   \        P                  # V# )r   r[  ro  r  Nr\   )r<  r  	mask_sizer   >	   r   r   r%  minstdsumvarmeanprodr^   )r   )r  rV   rX   r%   popr!   _wrap_na_resultr   rq   r3   r  r  rm   r-  rM  rN  )
rx   r<  r[  r\  r  rh   r
  r\   r  r  s
   &&$$,     r`   _reduceBaseMaskedArray._reduce  s     TTT(AA&AF ::D::D3tf.B::fd+DL4LLTLVLFF||++A+NN'))XXvh/F#^^A.Fxx...v<<<<== Mrc   c                   V ^8  d   QhRR/# rZ   r<  r   r^   )r_   s   "r`   ra   rb     s     	 	3 	rc   c               	    \        V\        P                  4      '       dS   V'       d   V P                  P	                  VR 7      pMV P                  P                  VR 7      pV P                  W%4      # V# r  )rp   rq   rr   rX   r   r   r-  )rx   r<  rh   r[  r  r\   s   &&&$$ r`   _wrap_reduction_result&BaseMaskedArray._wrap_reduction_result  sT    fbjj))zz~~4~0zz~~4~0**688rc   c               	   \         P                  ! V\        R 7      pV P                  R8X  d   RMRpVR9   d   TpMVR9   g   V P                  P                  ^8X  d"   V P                  P
                  P                  pMZ\        4       ;'       g    \        '       * pV'       d   RMRpV'       d   RMRp	RVR	VR
V	RV/V P                  P                  ,          p\         P                  ! ^.VR 7      p
V P                  WR7      # )r   Float32r  r  int32int64uint32r  r   r   ur   r	  )rd  medianrc  ra  skewkurtsem)r`  r%  )rq   r   rm   rs   itemsizer   r<  r   r   r   r3   r-  )rx   r<  r  r_  r\   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s   &$$$       r`   rg  BaseMaskedArray._wrap_na_result  s    wwy-"&**	"9Yy
JJ!H^#tzz':':a'?zz--22H"5"7"C"Ct8"5w7H$7XIXsHc9c:V

H !H-&&u&88rc   c                   V ^8  d   QhRR/# rk  r^   )r_   s   "r`   ra   rb   1  s     S SSrc   c               	    V^ 8X  dW   \        V\        P                  4      '       d7   V P                  V\        P                  ! VP
                  \        R7      4      # V P                  WW5R7      # )r   r   r[  r  )rp   rq   rr   r-  r  rv   rm   rm  )rx   r<  rh   r[  	min_countr  s   &&&$$$r`    _wrap_min_count_reduction_result0BaseMaskedArray._wrap_min_count_reduction_result1  sT     >j<<**6288FLLPT3UVV**4*RRrc   r  c               $    V ^8  d   QhRRRRRR/# rZ   r[  rm   r  r   r  AxisInt | Noner^   )r_   s   "r`   ra   rb   8  *     
 
 
 	

 
rc   c               	    \         P                  ! RV4       \        P                  ! V P                  V P
                  VVVR 7      pV P                  RWQW#R 7      # )r[  r  r  rb  r^   )r*  validate_sumr-   rb  rV   rX   r  rx   r[  r  r  r  rh   s   &$$$, r`   rb  BaseMaskedArray.sum8  sZ     	F#"&&JJJJ
 446I 5 
 	
rc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb   M  r  rc   c               	    \         P                  ! RV4       \        P                  ! V P                  V P
                  VVVR 7      pV P                  RWQW#R 7      # )r  re  r^   )r*  validate_prodr-   re  rV   rX   r  r  s   &$$$, r`   re  BaseMaskedArray.prodM  s\     	V$"''JJJJ
 44FY 5 
 	
rc   c                    V ^8  d   QhRRRR/# rZ   r[  rm   r  r  r^   )r_   s   "r`   ra   rb   b  s     U Ud U Urc   c               	    \         P                  ! RV4       \        P                  ! V P                  V P
                  VVR 7      pV P                  RWAVR 7      # )r  rd  r^   )r*  validate_meanr-   rd  rV   rX   rm  rx   r[  r  r  rh   s   &$$, r`   rd  BaseMaskedArray.meanb  sP    
V$"''JJJJ	
 **66t*TTrc   ddofc               $    V ^8  d   QhRRRRRR/# rZ   r[  rm   r  r  r  r   r^   )r_   s   "r`   ra   rb   l  )     T TT,:TFITrc   c               	    \         P                  ! RVR R7       \        P                  ! V P                  V P
                  VVVR7      pV P                  R WQVR7      # )rc  fnamer[  r  r  r  r^   )r*  validate_stat_ddof_funcr-   rc  rV   rX   rm  rx   r[  r  r  r  rh   s   &$$$, r`   rc  BaseMaskedArray.varl  W     	""2vU;"&&JJJJ
 **5&d*SSrc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb   y  r  rc   c               	    \         P                  ! RVR R7       \        P                  ! V P                  V P
                  VVVR7      pV P                  R WQVR7      # )ra  r  r  r  r^   )r*  r  r-   ra  rV   rX   rm  r  s   &$$$, r`   ra  BaseMaskedArray.stdy  r  rc   c                    V ^8  d   QhRRRR/# r  r^   )r_   s   "r`   ra   rb          T TT T Trc   c               	    \         P                  ! RV4       \        P                  ! V P                  V P
                  VVR 7      pV P                  RWAVR 7      # )r  r`  r^   )r*  validate_minr-   r`  rV   rX   rm  r  s   &$$, r`   r`  BaseMaskedArray.min  N    
F#"&&JJJJ	
 **5&d*SSrc   c                    V ^8  d   QhRRRR/# r  r^   )r_   s   "r`   ra   rb     r  rc   c               	    \         P                  ! RV4       \        P                  ! V P                  V P
                  VVR 7      pV P                  RWAVR 7      # )r  r%  r^   )r*  validate_maxr-   r%  rV   rX   rm  r  s   &$$, r`   r%  BaseMaskedArray.max  r  rc   c                   V ^8  d   QhRR/# )rZ   	na_actionzLiteral['ignore'] | Noner^   )r_   s   "r`   ra   rb     s     G G%= Grc   c                	8    \        V P                  4       WR 7      # ))r  )r)   rX  )rx   mapperr  s   &&&r`   mapBaseMaskedArray.map  s    &FFrc   c               $    V ^8  d   QhRRRRRR/# rZ   r[  zLiteral[True]r  r  r]   znp.bool_r^   )r_   s   "r`   ra   rb     $      &4B	rc   c               	    R # re   r^   rx   r[  r  r  s   &$$,r`   r   BaseMaskedArray.any       rc   c               $    V ^8  d   QhRRRRRR/# rZ   r[  rm   r  r  r]   znp.bool_ | NATyper^   )r_   s   "r`   ra   rb     $         %3 	 rc   c               	    R # re   r^   r  s   &$$,r`   r   r          rc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb     s)     I' I'I',:I'	I'rc   c                  \         P                  ! RV4       V P                  P                  4       p\        P
                  ! W@P                  V P                  P                  4       VP                  4       pV'       d   V# V'       g1   \        V 4      ^ 8X  g!   V P                  P                  4       '       g   V# V P                  P                  # )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.

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()
np.True_
>>> pd.array([True, False, pd.NA]).any()
np.True_
>>> pd.array([False, False, pd.NA]).any()
np.False_
>>> pd.array([], dtype="boolean").any()
np.False_
>>> pd.array([pd.NA], dtype="boolean").any()
np.False_
>>> pd.array([pd.NA], dtype="Float64").any()
np.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)
np.True_
>>> pd.array([1, 0, pd.NA]).any(skipna=False)
np.True_
>>> pd.array([False, False, pd.NA]).any(skipna=False)
<NA>
>>> pd.array([0, 0, pd.NA]).any(skipna=False)
<NA>
r^   )r*  validate_anyrV   rl   rq   putmaskrX   rs   _falsey_valuer   r   r   rx   r[  r  r  r[   rh   s   &$$,  r`   r   r    s    ~ 	F#"


6::tzz'?'?@Ms4yA~TZZ^^-=-=M::&&&rc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb     r  rc   c               	    R # re   r^   r  s   &$$,r`   r   BaseMaskedArray.all  r  rc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb     r  rc   c               	    R # re   r^   r  s   &$$,r`   r   r    r  rc   c               $    V ^8  d   QhRRRRRR/# r  r^   )r_   s   "r`   ra   rb     s)     J' J'J',:J'	J'rc   c                  \         P                  ! RV4       V P                  P                  4       p\        P
                  ! W@P                  V P                  P                  4       VP                  VR7      pV'       d   V# V'       d1   \        V 4      ^ 8X  g!   V P                  P                  4       '       g   V# V P                  P                  # )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.

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()
np.True_
>>> pd.array([1, 1, pd.NA]).all()
np.True_
>>> pd.array([True, False, pd.NA]).all()
np.False_
>>> pd.array([], dtype="boolean").all()
np.True_
>>> pd.array([pd.NA], dtype="boolean").all()
np.True_
>>> pd.array([pd.NA], dtype="Float64").all()
np.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)
np.False_
>>> pd.array([1, 0, pd.NA]).all(skipna=False)
np.False_
r  r^   )r*  validate_allrV   rl   rq   r  rX   rs   _truthy_valuer   r   r   r   r  s   &$$,  r`   r   r    s    ~ 	F#"


6::tzz'?'?@&M3t9>1A1AM::&&&rc   c               (    V ^8  d   QhRRRRRRRR/# )	rZ   r   rG   r  r   rl   rm   r]   rQ   r^   )r_   s   "r`   ra   rb   H  s4     29 29 #29 	29 29 
29rc   c                  V P                   P                  R8X  dW   V'       d6   V P                  P                  4       p	V P                  P                  4       p
MV P                  p	V P                  p
MkV P                   P                  R9   d9   RpV P                  P                  R4      p	V P                  P                  4       p
M\        RV P                    24      h\        P                  ! V	3RVR^ RVR	VR
VRVRV
/VB  V'       g   V # V P                   P                  R8X  d   \        V 4      P                  W4      # ^ RIHp VP                  ! W4      # )z"
See NDFrame.interpolate.__doc__.
r   r   Tf8z)interpolate is not implemented for dtype=r   r  r;  r   limit_directionr   r\   rP   )rs   r   rV   rl   rX   rS  r   r   interpolate_2d_inplacer   ri   r  rQ   )rx   r   r  r;  r   r  r   rl   r  r
  r\   rQ   s   &$$$$$$$,   r`   interpolateBaseMaskedArray.interpolateH  sA     ::??c!zz(zz(zzzzZZ__$D::$$T*D::??$D%;DJJ<H  	&&
	

	
 
	
 	
	

 
	
 ,
	
 "
	
 
	
 
	
 K::??c!:))$558 ,,T88rc   c               $    V ^8  d   QhRRRRRR/# )rZ   r<  r   r[  rm   r]   rT   r^   )r_   s   "r`   ra   rb   |  s$     	, 	,	,$(	,		,rc   c               	    V P                   pV P                  p\        \        V4      pV! WE3R V/VB w  rEV P	                  WE4      # )r[  )rV   rX   r  r,   ri   )rx   r<  r[  r  r
  r\   r  s   &&$,   r`   _accumulateBaseMaskedArray._accumulate|  sJ     zzzz)40<6<V<
++rc   c          
     ,    V ^8  d   QhRRRRRRRRRR	/# )
rZ   howr   has_dropped_narm   r  r   ngroupsidsznpt.NDArray[np.intp]r^   )r_   s   "r`   ra   rb     sE     -D -D -D 	-D
 -D -D "-Drc   c               	d   ^ RI Hp VP                  V4      pV! WVR7      p	V P                  p
V	P                  R8w  d   V
P                  4       pM\        P                  ! V\        R7      pVR8X  d   VP                  R4      R9   d   RVR&   V	P                  ! V P                  3R	VR
VRVRV
RV/VB pV	P                  R8X  dI   V	P                  P                  V	P                  ^4      p\        P                  ! W^34      P                  pV	P                  R9   d   V# V P!                  W4      # )r   )WrappedCythonOp)r  r   r  	aggregater   rankr  Fr   r  r  comp_idsr\   result_maskohlcr
  )idxminidxmax)pandas.core.groupby.opsr  get_kind_from_howrX   r   rl   rq   r  rm   r  _cython_op_ndim_compatrV   r  _cython_aritytiler   r-  )rx   r  r  r  r  r  r  r  r   r  r\   r  
res_valuesaritys   &$$$$$,       r`   _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Crc   )rV   rX   )Fr  )r   )r   N).)T)NNre   )r   )rP  N)[r  
__module____qualname____firstlineno____doc____annotations__classmethodri   ry   r   r   r   r   propertyrs   r	   r   r   r   r~   r   r   r   r   r   rv   r   r  r  r  r  r/   r   r,  r2  r7  r<  rA  rF  r   rq  rX  r^  rS  __array_priority__ru  r  r  r   r  r  _logical_methodr  r-  r!   r  r  r  r  r+   r(   rl   r  r  r  r  r/  r3  rA  rI  rR  rY  rh  rm  rg  r  rb  re  rd  rc  ra  r`  r%  r  r   r   r  r  r  __static_attributes____classcell__)r   s   @r`   rT   rT   z   s       & !d ! ! !  ( ( ( : := =) !	)
 ;?) )V;z '6;' '
O4,/ /       ,
,
,
&	. < <BF@@D
.
 '+>>	^@K: O OT TJ J,\ 50 %$M'^@ & &c5J $O*6X3j! # # 5 5  ". !	".
 %)". ".L6(,
)0 )0  	)0
  )0 )0 )0V!>F	/:HxN!` D(BT(
0Pd';X+/BG:	9&S
 
 	

  !
*
 
 	

  !
*UT U! UT $T=>TLMTT $T=>TLMTTD T TTD T TG ),EH   69   I' $I'=>I'V ),EH   69   J' $J'=>J'X29h	,+/	,-D -Drc   rT   c                    V ^8  d   QhRRRR/# )rZ   masked_arrayszSequence[BaseMaskedArray]r]   zlist[BaseMaskedArray]r^   )r_   s   "r`   ra   ra     s     ! !,!!rc   c                   \        V 4      p V ^ ,          P                  pV  Uu. uF  q"P                  P                  ^R4      NK   	  pp\        P
                  ! V^ \        P                  ! \        V 4      \        V ^ ,          4      3RVP                  R7      R7      pV  Uu. uF  q"P                  P                  ^R4      NK   	  pp\        P
                  ! V^ \        P                  ! V\        R7      R7      pVP                  4       p. p\        VP                  ^,          4       F0  p	V! VRV	3,          VRV	3,          R7      p
VP                  V
4       K2  	  V# u upi u upi )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.
F)orderrs   )r  r{  r   r   r	  r   )r[  rs   rV   r  rq   r  r   r   r   rX   
empty_likerm   rn  r   rv   r  )r  rs   r'  r[   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs   &          r`   #transpose_homogeneous_masked_arraysr    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$)u
__future__r   typingr   r   r   r   r   r	   rO  numpyrq   pandas._configr
   r   pandas._libsr   r  r   r   rM  pandas._libs.tslibsr   pandas.compatr   r   pandas.errorsr   pandas.core.dtypes.astyper   pandas.core.dtypes.baser   pandas.core.dtypes.castr   pandas.core.dtypes.commonr   r   r   r   r   r   pandas.core.dtypes.dtypesr   r   pandas.core.dtypes.missingr   r    r!   r"   pandas.corer#   r$   r%   r&   pandas.core.algorithmsr'   r(   r)   r*   r+   pandas.core.array_algosr,   r-    pandas.core.array_algos.quantiler.   "pandas.core.array_algos.transformsr/   pandas.core.arrayliker0   pandas.core.arrays._utilsr1   pandas.core.arrays.baser2   pandas.core.constructionr3   r  r4   r5   pandas.core.indexersr6   r7   pandas.core.opsr8   pandas.core.util.hashingr9   collections.abcr:   r;   r<   r=  r=   r  r?   pandas._typingr@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   pandas._libs.missingrO   rQ   pandas.compat.numpyrR   r*  rT   r  r^   rc   r`   <module>r+     s    "   
 
 3 . 4 2     @ 4 * > 2 
 / /( /    " ,0 .}Dh }D@:!rc   