
    |och                    T   d dl mZ d dlmZmZmZmZmZ d dlZd dl	Z
d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m!Z!m"Z" d dl#m$Z$ d d	l%m&Z& d d
l'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z: d dl;m<Z=m>Z>mZm?Z?m@Z@ d dlAmBZBmCZCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZTmUZUmVZV d dlWmXZX d dlYmZZZ d dl[m\Z\ er"d dl]m^Z^m_Z_ d dl`maZa d dlbmcZc d dlmdZdmeZe d dlbmfZf d d lgmhZi  G d! d"eMeQ      Zj	 	 	 	 d$d#Zky)%    )annotations)TYPE_CHECKINGAnyCallableLiteraloverloadN)libmissing)is_supported_dtype)	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSelfSequenceIndexerShapenpt)IS64is_platform_windowsAbstractMethodError)doc)find_stack_level)validate_fillna_kwargs)ExtensionDtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker
   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexer)invalid_comparison)
hash_array)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLikeFloatingArray)functionc                      e Zd ZU dZded<   ded<   ded<   eZeZedgd       Z		 dh	 	 	 	 	 	 	 did
Z
edd	ddjd       Ze eej                        dkd              ZdhdldZedmd       Zednd       Zedod       ZdpdZdddd	 	 	 	 	 	 	 	 	 dqdZ eej*                        	 dr	 	 	 	 	 dsd       Zed	d	 	 	 	 	 dtd       Zd ZdudZdv fdZdwdZdxdZedyd       Zedxd        Zdzd!Zd{d|d#Zdzd$Z dzd%Z!edzd&       Z"d{d}d'Z#dzd(Z$dzd)Z%dzd*Z&dzd+Z'd~d,Z(dd	e)jT                  f	 	 	 	 	 	 	 dd-Z+ eejX                        d.        Z,eddd/       Z-eddd0       Z-eddd1       Z-ddd2Z-d3Z.	 d	 	 	 	 	 dd4Z/d5ed6<   dd7Z0dd8Z1edvd9       Z2	 	 	 	 dd:Z3d; Z4e4Z5dd<Z6	 	 	 	 dd=Z7d~d>Z8ed?        Z9edxd@       Z:e	 d{	 	 	 	 	 ddA       Z;	 	 	 	 	 	 	 	 ddBZ<d	dd"dC	 	 	 	 	 	 	 ddDZ=ddEZ>dzdFZ? eej                        	 d	 	 	 ddG       Z@dzdHZA eej                        	 	 d	 	 	 	 	 	 	 ddI       ZB eej                        	 d	 	 	 ddJ       ZC eej                        d~dK       ZDdddLZEdddMZF eej                        dvdN       ZG	 	 	 	 	 	 ddOZHdd	dP	 	 	 	 	 ddQZIddRZJdS ZK	 	 ddTZLdd"d"dU	 	 	 	 	 ddVZMdd"d"dU	 	 	 	 	 ddWZNdd"dXddYZOdd"dZd[	 	 	 	 	 dd\ZPdd"dZd[	 	 	 	 	 dd]ZQdd"dXdd^ZRdd"dXdd_ZSdd`ZTdd"dXddaZUdd"dXddbZV	 	 	 	 	 	 	 	 ddcZWddd	 	 	 	 	 ddeZX	 	 	 	 	 	 	 	 	 	 ddfZY xZZS )BaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   _internal_fill_value
np.ndarray_datanpt.NDArray[np.bool_]_maskc                L    t         j                  |       }||_        ||_        |S N)rM   __new__rP   rR   )clsvaluesmaskresults       h/mnt/ACDE16A4DE16673C/PROJECTS/MIS_PORTAL/venv/lib/python3.12/site-packages/pandas/core/arrays/masked.py_simple_newzBaseMaskedArray._simple_new}   s%     ((-    Fc                0   t        |t        j                        r|j                  t        j                  k(  st        d      |j                  |j                  k7  rt        d      |r |j                         }|j                         }|| _	        || _
        y )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)
isinstancenpndarraydtypebool_	TypeErrorshape
ValueErrorcopyrP   rR   )selfrW   rX   rf   s       rZ   __init__zBaseMaskedArray.__init__   sx     4,rxx1G2  <<4::%ABB[[]F99;D

r\   Nra   rf   c               B    | j                  |||      \  }} | ||      S )Nri   )_coerce_to_array)rV   scalarsra   rf   rW   rX   s         rZ   _from_sequencezBaseMaskedArray._from_sequence   s*    ++G5t+L64  r\   c                   t        j                  ||j                        }|j                  | j                         t        j
                  |t              } | ||      }t        ||       r||j                  k7  rt        d| d      |S )Nra   z5Default 'empty' implementation is invalid for dtype='')
r_   emptytypefillrN   onesboolr^   ra   NotImplementedError)rV   rd   ra   rW   rX   rY   s         rZ   _emptyzBaseMaskedArray._empty   s{     %uzz2C,,-wwuD)VT"&#&%6<<*?%GwaP  r\   c                    t         S rT   )str)rg   boxeds     rZ   
_formatterzBaseMaskedArray._formatter   s    
r\   c                    t        |       rT   r   rg   s    rZ   ra   zBaseMaskedArray.dtype   s    !$''r\   c                     y rT    rg   items     rZ   __getitem__zBaseMaskedArray.__getitem__       r\   c                     y rT   r   r   s     rZ   r   zBaseMaskedArray.__getitem__   r   r\   c                    t        | |      }| j                  |   }t        |      r'|r| j                  j                  S | j
                  |   S | j                  | j
                  |   |      S rT   )r?   rR   r"   ra   na_valuerP   r[   )rg   r   newmasks      rZ   r   zBaseMaskedArray.__getitem__   sb    "4.**T"7zz***::d##

4 0'::r\   T)limit
limit_arearf   c                  | j                   }|j                         rMt        j                  || j                        }| j
                  j                  }|j                  }|r!|j                         }|j                         }n||j                         } ||||       ||j                         s|j                  }| }	|	j                         }
t        |	      |	d d d   j                         z
  dz
  }|dk(  r)|d |
xxx |d |
 z  ccc ||dz   d xxx ||dz   d  z  ccc n|dk(  r||
dz   |xxx ||
dz   | z  ccc |r&| j                  |j                  |j                        S | S |r| j                         }|S | }|S )Nndimr   rX      insideoutside)rR   anyr
   get_fill_funcr   rP   Trf   allargmaxlenr[   )rg   methodr   r   rf   rX   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                rZ   _pad_or_backfillz BaseMaskedArray._pad_or_backfill   sv    zz88:((dii@Dzz||HvvH#==?#==?'yy{X6%dhhjvv 5 )8}x"~'<'<'>>B)Ve$Ve4$TAXZ(D,<<(9,UQY.$uqy42HH.''

HJJ??!YY[
  "
r\   c                <   t        ||      \  }}| j                  }t        j                  ||t	        |             }|j                         r|t        j                  || j                        }| j                  j                  }|j                  }|r |j                         }|j                         } ||||       | j                  |j                  |j                        S |r| j                         }	n| d d  }	||	|<   |	S |r| j                         }	|	S | d d  }	|	S )Nr   r   )r    rR   r
   check_value_sizer   r   r   r   rP   r   rf   r[   )
rg   valuer   r   rf   rX   r   r   r   r   s
             rZ   fillnazBaseMaskedArray.fillna   s    /uf=vzz((c$i@88:!,,V$))D::<<66'}}H'}}HXU:''

HJJ?? !%J!%aJ#(
4  	 !YY[
  "!W
r\   rf   c                   t        |       rT   r   )rV   rW   ra   rf   s       rZ   rk   z BaseMaskedArray._coerce_to_array  s     "#&&r\   c                x   | j                   j                  }|dk(  rt        j                  |      ro|S |dk(  r,t        j                  |      st        j
                  |      r>|S t        j                  |      s%t        j
                  |      r|j	                         r|S t        d|d| j                    d      )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        bfzInvalid value 'z' for dtype 'rp   )ra   kindr	   r"   
is_integeris_floatrc   )rg   r   r   s      rZ   _validate_setitem_valuez'BaseMaskedArray._validate_setitem_value  s     zz3;{{5!S[~~e$U(; ~~e$e)<AQAQAS
 /%-

|1MNNr\   c                Z   t        | |      }t        |      rVt        || j                        rd| j                  |<   y | j                  |      }|| j                  |<   d| j                  |<   y | j                  || j                        \  }}|| j                  |<   || j                  |<   y )NTFro   )r?   r%   r*   ra   rR   r   rP   rk   )rg   keyr   rX   s       rZ   __setitem__zBaseMaskedArray.__setitem__4  s    !$,U$UDJJ7"&

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

3"'

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

3

3r\   c                r   t        |      r|| j                  j                  ur|| j                  j                  j                  dk(  rYt        j                  |      rDt        t        j                  | j                        | j                   z  j                               S t        t        | 5  |            S )Nr   )r+   ra   r   rP   r   r	   r   ru   r_   isnanrR   r   super__contains__)rg   r   	__class__s     rZ   r   zBaseMaskedArray.__contains__E  s    9DJJ$7$77zz$$+S0ARXXdjj1TZZK?DDFGGEG(-..r\   c              #  B  K   | j                   dk(  rl| j                  s| j                  D ]  }|  y | j                  j                  }t        | j                  | j                        D ]  \  }}|r| |  y t        t        |             D ]	  }| |     y w)Nr   )	r   _hasnarP   ra   r   ziprR   ranger   )rg   valr   isna_is        rZ   __iter__zBaseMaskedArray.__iter__M  s     99>;;:: CI  ::.."%djj$**"= "JE3&!		" 3t9% 1gs   BBc                ,    t        | j                        S rT   )r   rP   r}   s    rZ   __len__zBaseMaskedArray.__len__]  s    4::r\   c                .    | j                   j                  S rT   )rP   rd   r}   s    rZ   rd   zBaseMaskedArray.shape`  s    zzr\   c                .    | j                   j                  S rT   )rP   r   r}   s    rZ   r   zBaseMaskedArray.ndimd  s    zzr\   c                    | j                   j                  ||      }| j                  j                  ||      }| j                  ||      S rT   )rP   swapaxesrR   r[   )rg   axis1axis2datarX   s        rZ   r   zBaseMaskedArray.swapaxesh  sA    zz""5%0zz""5%0d++r\   r   c                    t        j                  | j                  ||      }t        j                  | j                  ||      }| j	                  ||      S Naxis)r_   deleterP   rR   r[   )rg   locr   r   rX   s        rZ   r   zBaseMaskedArray.deletem  sA    yySt4yySt4d++r\   c                     | j                   j                  |i |} | j                  j                  |i |}| j                  ||      S rT   )rP   reshaperR   r[   rg   argskwargsr   rX   s        rZ   r   zBaseMaskedArray.reshaper  sK    !tzz!!4262!tzz!!4262d++r\   c                     | j                   j                  |i |} | j                  j                  |i |} t        |       ||      S rT   )rP   ravelrR   rr   r   s        rZ   r   zBaseMaskedArray.ravelw  sK    tzz00tzz00tDz$%%r\   c                v    | j                  | j                  j                  | j                  j                        S rT   )r[   rP   r   rR   r}   s    rZ   r   zBaseMaskedArray.T}  s%    

djjll;;r\   c                    | j                   j                  dk(  r| S t        j                  ||       t	        j
                  | j                  fd|i|}| j                  || j                  j                               S )a  
        Round each value in the array a to the given number of decimals.

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

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

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r   decimals)
ra   r   nvvalidate_roundr_   roundrP   _maybe_mask_resultrR   rf   )rg   r   r   r   rW   s        rZ   r   zBaseMaskedArray.round  se    0 ::??c!K
$'$**BxB6B &&vtzz/@AAr\   c                l    | j                  | j                   | j                  j                               S rT   r[   rP   rR   rf   r}   s    rZ   
__invert__zBaseMaskedArray.__invert__  &    TZZ__->??r\   c                l    | j                  | j                   | j                  j                               S rT   r   r}   s    rZ   __neg__zBaseMaskedArray.__neg__  r   r\   c                "    | j                         S rT   r   r}   s    rZ   __pos__zBaseMaskedArray.__pos__  s    yy{r\   c                |    | j                  t        | j                        | j                  j	                               S rT   )r[   absrP   rR   rf   r}   s    rZ   __abs__zBaseMaskedArray.__abs__  s(    DJJ1BCCr\   c                8    t        j                  | t              S )Nro   )r_   asarrayobjectr}   s    rZ   _values_for_jsonz BaseMaskedArray._values_for_json  s    zz$f--r\   c                b   | j                   }t        | |||      \  }}|t        }|r|t        k7  r,t        |      s!|t        j
                  u rt        d| d      t        j                         5  t        j                  dt               | j                  j                  |      }ddd       || j                  <   |S t        j                         5  t        j                  dt               | j                  j                  ||      }ddd       |S # 1 sw Y   qxY w# 1 sw Y   S xY w)aF  
        Convert to a NumPy Array.

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

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

        Returns
        -------
        numpy.ndarray

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

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

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

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

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

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

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

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.ignorecategoryr   )r   r:   r   r&   
libmissingNAre   warningscatch_warningsfilterwarningsRuntimeWarningrP   astyperR   )rg   ra   rf   r   hasnar   s         rZ   to_numpyzBaseMaskedArray.to_numpy  s   D 24%Px=E'.
- )% 1& &  ((* 0''>Jzz((/0  (D
  ((* ;''>Jzz((T(:; 0 0
; s   17D9D$D!$D.c                   | j                   dkD  r| D cg c]  }|j                          c}S | j                  rd n| j                  j                  }| j                  |t        j                        j                         S c c}w )Nr   ra   r   )r   tolistr   rP   ra   r   r   r   )rg   xra   s      rZ   r   zBaseMaskedArray.tolist  s`    99q=(,-1AHHJ--)9)9}}5:==}AHHJJ .s   Bc                     y rT   r   rg   ra   rf   s      rZ   r   zBaseMaskedArray.astype  r   r\   c                     y rT   r   r   s      rZ   r   zBaseMaskedArray.astype  r   r\   c                     y rT   r   r   s      rZ   r   zBaseMaskedArray.astype!  r   r\   c                   t        |      }|| j                  k(  r|r| j                         S | S t        |t              rt        j                         5  t        j                  dt               | j                  j                  |j                  |      }d d d        | j                  u r| j                  n| j                  j                         }|j                         } |||d      S t        |t              r$|j                         }|j                  | ||      S |j                   dk(  rt"        j$                  }n5|j                   dk(  rt#        j&                  d      }nt(        j*                  }|j                   d	v r| j,                  rt/        d
      |j                   dk(  r| j,                  rt/        d      | j1                  |||      }|S # 1 sw Y   CxY w)Nr   r   r   Fri   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)ra   r   rf   )r'   ra   rf   r^   r(   r   r   r   r   rP   r   numpy_dtyperR   construct_array_typer!   rm   r   r_   nan
datetime64r	   
no_defaultr   re   r   )rg   ra   rf   r   rX   rV   eaclsr   s           rZ   r   zBaseMaskedArray.astype%  s   U#DJJyy{"K e_-((* G''>Jzz(():):(FG "&!34::9JD,,.CtT..e^,..0E''E'EE
 ::vvHZZ3}}U+H~~H ::$++;<<::?@@}}58$}GCG Gs   AGG!i  c                    |du rR| j                   s"t        j                  | j                  ||      S t	        j
                  dt        t                      |d}| j                  ||      S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        Fri   aS  Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.)
stacklevel)	r   r_   r<   rP   r   warnFutureWarningr   r   r   s      rZ   	__array__zBaseMaskedArray.__array__U  sd     5=;;xx

%dCCMM2 +-	 <D}}5t}44r\   ztuple[type, ...]_HANDLED_TYPESc                8  	
 |j                  dd      }||z   D ](  }t        || j                  t        fz         r"t        c S  t        j                  | ||g|i |}|t        ur|S d|v rt        j                  | ||g|i |S |dk(  r%t        j                  | ||g|i |}|t        ur|S t        j                  t        |       t              	g }|D ]N  }t        |t              r+	|j                  z  	|j                  |j                         >|j                  |       P d	fd
 t!        ||      |i |}|j"                  dkD  rt%        
fd|D              S |dk(  r(| j                  j'                         r| j(                  S |S  
|      S )	Noutr   reducero   c                   ddl m}m}m} | j                  j
                  dk(  rj                         } || |      S | j                  j
                  dv rj                         } || |      S | j                  j
                  dk(  rUj                         }| j                  t        j                  k(  r| j                  t        j                        }  || |      S t        j                  | <   | S )Nr   )rF   rJ   IntegerArrayr   r  r   )pandas.core.arraysrF   rJ   r  ra   r   rf   r_   float16r   float32r  )r   rF   rJ   r  mrX   s        rZ   reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s      ww||s"IIK#Aq))%IIK#Aq))$IIK77bjj( ,A$Q**&&$Hr\   r   c              3  .   K   | ]  } |        y wrT   r   ).0r   r  s     rZ   	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s     8AQ8s   )r   rO   )getr^   r  rM   NotImplementedr.   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncr_   zerosr   ru   rR   appendrP   getattrnouttupler   	_na_value)rg   ufuncr   inputsr   r  r   rY   inputs2rX   r  s            @@rZ   __array_ufunc__zBaseMaskedArray.__array_ufunc__r  s    jj## 	&Aa!4!47I!IJ%%	&
 <<%
"(
,2
 'MF?44eV&,06  X77eV&,06F ^+xxD	. 	"A!_-qww'q!	"	4 (';F;::>8888xzz~~~~%Mv&&r\   c                Z    ddl }|j                  | j                  | j                  |      S )z6
        Convert myself into a pyarrow Array.
        r   N)rX   rr   )pyarrowr<   rP   rR   )rg   rr   pas      rZ   __arrow_array__zBaseMaskedArray.__arrow_array__  s$     	xx

$x??r\   c                6    | j                   j                         S rT   )rR   r   r}   s    rZ   r   zBaseMaskedArray._hasna  s     zz~~r\   c                    |e| j                   j                         }|t        j                  u r|dz  }|S t	        |      r%t        |      t        |      k(  r|t        |      z  }|S | j                   |z  }|S )NT)rR   rf   r   r   r$   r   r+   )rg   rX   others      rZ   _propagate_maskzBaseMaskedArray._propagate_mask  sz     <::??$D
%d{  e$Us4y)@d5k)
  ::$D r\   c                   |j                   }d }t        |d      s:t        |      r/t        |      t        |       k(  rt	        |      }t        |d      }t        |t              r|j                  |j                  }}nJt        |      r?t        |t              st        j                  |      }|j                  dkD  rt        d      t        j                   |t        |       f      }t        j"                  |      }t%        |      }|dv r%t        |t        j&                        rt)        |      }| j+                  ||      }|t,        j.                  u rt        j0                  | j                        }| j2                  j4                  dk(  r.|dv rt        d	| d
      |dv rd}nd}|j7                  |      }nd|v r| j2                  j4                  dk7  rp|j7                  t        j8                        }nP| j2                  j4                  dv r|dv r|}t        j:                  d      5   || j                  |      }d d d        |dk(  rt        j<                  | j                  dk(  | j                   z  d|      }|t        j<                  |dk(  | z  d|      }n|t,        j.                  urt        j<                  |dk(  d|      }n|dk(  r|t        j<                  |dk(  | z  d|      }n,|t,        j.                  urt        j<                  |dk(  d|      }t        j<                  | j                  dk(  | j                   z  d|      }| j?                  |      S # 1 sw Y   %xY w)Nra   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   r6  r7  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8ru   r8  r   r  )r9  r<  r   )r   r6  Fr   r7  ) __name__hasattrr$   r   pd_arrayr>   r^   rM   rP   rR   r;   r_   r   r   rv   r0   maybe_prepare_scalar_for_opget_array_opr=   rb   ru   r2  r   r   	ones_likera   r   r   float64errstatewherer   )	rg   r1  opop_nameomaskpd_oprX   rY   ra   s	            rZ   _arith_methodzBaseMaskedArray._arith_method  s   ++ w'U#E
c$i' UOE!%t<Ee_- ;;5E% e^4

5)zzA~)*TUU //D	|D  $.u5o%*UBHH*E KE##E51JMM!\\$**-Fzz#%   .$WI-NO  o-"E"Eu-g%$**//S*@  rzz2 zz$&76I+I * 2tzz512 e88TZZ1_;UDID xx!v 5udCjmm+xx
E48 xx!v 5udCjmm+xx
E4888TZZ1_;UDID&&vt44+2 2s   ,M##M-c                |   ddl m} d }t        |t              r|j                  |j
                  }}n\t        |      rQt        j                  |      }|j                  dkD  rt        d      t        |       t        |      k7  rt        d      |t        j                  u rWt        j                  | j                  j                   d      }t        j"                  | j                  j                   d      }nt%        j&                         5  t%        j(                  dd	t*               t%        j(                  dd	t,               t/        | j                  d
|j0                   d
      } ||      }|t2        u rt5        | j                  ||      }d d d        | j7                  ||      } ||d      S # 1 sw Y   &xY w)Nr   rE   r   r5  zLengths must match to compareru   ro   r   elementwise__Fr   )r  rF   r^   rM   rP   rR   r$   r_   r   r   rv   r   re   r   r   r!  rd   rt   r   r   r   r  DeprecationWarningr#  r?  r  r@   r2  )rg   r1  rH  rF   rX   rY   r   s          rZ   _cmp_methodzBaseMaskedArray._cmp_method?  s_   3e_-++u{{4E% JJu%EzzA~)*TUU4yCJ& !@AAJMM!
 XXdjj..f=F774::++6:D((* G ''-O''-AST r"++b-AB^+/

E2FFG ##D%0FDu55G Gs   BF22F;c                   t        |t              r)|\  }}| j                  ||      | j                  ||      fS |j                  j                  dk(  rddlm}  |||d      S |j                  j                  dk(  rddlm}  |||d      S t        j                  |j                  d      rdt        |j                        rOdd	lm} |j                  j                  d
      ||<   t        ||      s|j                  ||j                        S |S |j                  j                  dv rddlm}  |||d      S t        j                   ||<   |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r   r   rI   Fr   r   rE   r  )TimedeltaArrayr  ro   r  r  )r^   r%  r   ra   r   r  rJ   rF   r	   is_np_dtyper   rS  rr   r[   r  r_   r  )	rg   rY   rX   divr<  rJ   rF   rS  r  s	            rZ   r   z"BaseMaskedArray._maybe_mask_resultg  s%    fe$HC''T2''T2 
 <<#8 E::\\#%7599__V\\3/4Fv||4T9!<<,,U3F4Lfn5%11&1MMM\\$&7599 66F4LMr\   c                6    | j                   j                         S rT   )rR   rf   r}   s    rZ   r+   zBaseMaskedArray.isna  s    zz  r\   c                .    | j                   j                  S rT   r   r}   s    rZ   r&  zBaseMaskedArray._na_value  s    zz"""r\   c                \    | j                   j                  | j                  j                  z   S rT   )rP   nbytesrR   r}   s    rZ   rZ  zBaseMaskedArray.nbytes  s!    zz  4::#4#444r\   c                    t        j                  |D cg c]  }|j                   c}|      }t        j                  |D cg c]  }|j                   c}|      } | ||      S c c}w c c}w r   )r_   concatenaterP   rR   )rV   	to_concatr   r   r   rX   s         rZ   _concat_same_typez!BaseMaskedArray._concat_same_type  sV     ~~	:1qww:F~~	:1qww:F4 ;:s   A(A-c                   t        | j                  |||      }t        | j                  j                        || j                         <   |S )N)encodinghash_key
categorize)rA   rP   hashra   r   r+   )rg   r`  ra  rb  hashed_arrays        rZ   _hash_pandas_objectz#BaseMaskedArray._hash_pandas_object  sB     "JJH
 %))<)<$=TYY[!r\   )
allow_fill
fill_valuer   c                  t        |      r| j                  n|}t        | j                  ||||      }t        | j                  |d||      }|r-t        |      r"t        j                  |      dk(  }|||<   ||z  }| j                  ||      S )N)rg  rf  r   Tr   )	r+   rN   r5   rP   rR   r,   r_   r   r[   )	rg   indexerrf  rg  r   data_fill_valuerY   rX   	fill_masks	            rZ   r5   zBaseMaskedArray.take  s     8<J7G$33ZJJ&!
 JJDZd
 %
+

7+r1I *F9)#D--r\   c                b    ddl m} t        j                  |      }t	         j
                  |      } j                  r8|j                  t        k(  xr t         fd|D              }|| j                  <   t        j                   j
                  j                  t              } |||d      S )Nr   rE   c              3  N   K   | ]  }|j                   j                  u   y wrT   r   )r  r   rg   s     rZ   r  z'BaseMaskedArray.isin.<locals>.<genexpr>  s'      @/2tzz***@s   "%ro   Fr   )r  rF   r_   r   r2   rP   r   ra   r   r   rR   r!  rd   ru   )rg   rW   rF   
values_arrrY   values_have_NArX   s   `      rZ   r2   zBaseMaskedArray.isin  s    3 ZZ'
djj*-;;'--7 C @6@@ =N "0F4::xx

((5FDu55r\   c                    | j                   j                         }| j                  j                         }| j                  ||      S rT   )rP   rf   rR   r[   )rg   r   rX   s      rZ   rf   zBaseMaskedArray.copy  s5    zz zz d++r\   c                b    | j                   }| j                  }t        j                  |||      S )N)keeprX   )rP   rR   algos
duplicated)rg   rr  rW   rX   s       rZ   rt  zBaseMaskedArray.duplicated  s+     zzT==r\   c                    t        j                  | j                  | j                        \  }}| j	                  ||      S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rs  unique_with_maskrP   rR   r[   )rg   uniquesrX   s      rZ   uniquezBaseMaskedArray.unique  s5     ..tzz4::F..r\   c                    | j                   rt        d      t        |t              r|j	                  t
              }| j                  j                  |||      S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)sidesorter)r   re   r^   r;   r   r   rP   searchsorted)rg   r   rz  r{  s       rZ   r|  zBaseMaskedArray.searchsorted  sS     ;;$  e^,LL(Ezz&&u4&GGr\   c                   | j                   }| j                  }t        |d|      \  }}|j                  | j                  j                  k(  sJ |j                  | j                  f       |j                         }|s|st        |      }nt        |      dz   }t        j                  |t              }|sw|ru|j                         }	|	dk(  rt        j                  d      }
n|d |	 j                         dz   }
|||
k\  xx   dz  cc<   |
||dk(  <   t        j                  ||
d      }d||
<   | j                  ||      }||fS )NT)use_na_sentinelrX   r   ro   r   r   )rP   rR   r1   ra   r  r   r   r_   r!  ru   r   intpmaxinsertr[   )rg   r~  arrrX   codesrw  has_nasizeuniques_maskna_indexna_code
uniques_eas               rZ   	factorizezBaseMaskedArray.factorize  s-   
 jjzz )dNw }}

 6 66S

8SS6&w<D w<!#DxxD16{{}H1}''!*	*..014%7"#q(#!(E%2+ii!4G$(L!%%g|<
j  r\   c                    | j                   S rT   )rP   r}   s    rZ   _values_for_argsortz#BaseMaskedArray._values_for_argsort:  s    zzr\   c                   ddl m}m} ddlm} t        j                  | j                  || j                        \  }}}t        j                  t        |      ft        j                        }|j                         }	|dkD  rd|d<    |||	      }
 | | j                  j                         ||            } ||
|dd	
      S )aA  
        Returns a Series containing counts of each unique value.

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

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )IndexrD   rT  dropnarX   ro   Tr   countF)indexnamerf   )pandasr  rD   pandas.arraysr  rs  value_counts_arraylikerP   rR   r_   r!  r   rb   rf   ra   r  )rg   r  r  rD   r  keysvalue_counts
na_counter
mask_indexrX   r  r  s               rZ   r  zBaseMaskedArray.value_counts>  s    "	
 	/).)E)EJJvDJJ*
&lJ XXs<02"((C
 >!JrN<.-DJJ++-j

 cW5AAr\   c                >   |rRt        | j                  || j                        }t        j                  |j
                  t        j                        }n%t        | j                  || j                        \  }} t        |       ||      }||j                            S )Nr  ro   )	r4   rP   rR   r_   r!  rd   rb   rr   argsort)rg   r  rY   res_masks       rZ   _modezBaseMaskedArray._modef  sr    $**V$**EFxxBHH=H#DJJvDJJOFHdFH-fnn&''r\   c                B   t        |       t        |      k7  ry|j                  | j                  k7  ryt        j                  | j                  |j                        sy| j
                  | j                      }|j
                  |j                      }t        ||dd      S )NFT)
strict_nandtype_equal)rr   ra   r_   array_equalrR   rP   r)   )rg   r1  leftrights       rZ   equalszBaseMaskedArray.equalso  s|    :e$;;$**$ ~~djj%++6zz4::+&U[[L)e$OOr\   c                   t        | j                  | j                  t        j                  ||      }| j
                  r| j                  dk(  rt        | j                         j                         rpt        j                  |j                  t              }t        | j                        rt        j                  |j                  | j                  j                         }nKt        j                  |j                  t              }n%t        j                  |j                  t              }| j#                  ||      S )z
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rX   rg  qsinterpolation   ro   rX   )r8   rP   rR   r_   r  r   r   rv   r+   r   rt   rd   ru   r#   ra   r!  r  r   )rg   r  r  resout_masks        rZ   	_quantilezBaseMaskedArray._quantile  s     !JJ vv'
 ;; yyA~ *)yy{ 77399D9#DJJ/ ((399DJJ4J4JKC88CIIT:xx		6H&&s&::r\   )skipnakeepdimsc                  |dv r t        | |      dd|i|}nJ| j                  }| j                  }t        t        d|       }|j	                  dd       }	 ||f|	||d|}|r]t        |      r| j                  |dd      S |j                  d	      }t        j                  d	t        
      }| j                  ||      S t        |      rt        j                  S |S )N>	   r   r   r  minstdsumvarmeanprodr  r  r   )r   r  rX   r   )r   )r  r   	mask_sizer   ro   r   )r#  rP   rR   r/   popr+   _wrap_na_resultr   r_   r!  ru   r   r   r   )
rg   r  r  r  r   rY   r   rX   rH  r   s
             rZ   _reducezBaseMaskedArray._reduce  s     TT(WT4(AA&AF ::D::D3tf.B::fd+DL4TLVLFF|++A+NN*xx...vt<<<== Mr\   c                   t        |t        j                        rM|r| j                  j	                  |      }n| j                  j                  |      }| j                  ||      S |S r   )r^   r_   r`   rR   r   r   r   )rg   r  rY   r  r   rX   s         rZ   _wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result  sS    fbjj)zz~~4~0zz~~4~0**6488r\   c                  t        j                  |t              }| j                  dk(  rdnd}|dv r|}n{|dv s| j                  j                  dk(  r!| j                  j
                  j                  }n=t               xs t         }|rdnd	}|rd
nd}	|||	|d| j                  j                     }t        j                  dg|      }
| j                  |
|      S )Nro   Float32r  rE  )r  medianr  r  skewkurt)r  r     int32int64uint32uint64)r   r   ur   r   r  )r_   rt   ru   ra   itemsizer  r  r   r   r   r<   r   )rg   r  r   r  rX   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              rZ   r  zBaseMaskedArray._wrap_na_result  s    wwy-"&**	"9Yy
CC!H^#tzz':':a'?zz--22H"5"7"Ct8"5w7H$7XI%H9:V

H !H-&&u4&88r\   c                   |dk(  rOt        |t        j                        r5| j                  |t        j                  |j
                  t                    S | j                  ||||      S )Nr   ro   r  r   )r^   r_   r`   r   r!  rd   ru   r  )rg   r  rY   r  	min_countr   s         rZ    _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_result  sU     >j<**6288FLLPT3UVV**4T*RRr\   r  r  r   c                   t        j                  d|       t        j                  | j                  | j
                  |||      }| j                  d||||      S )Nr   r  r  )r   validate_sumr7   r  rP   rR   r  rg   r  r  r   r   rY   s         rZ   r  zBaseMaskedArray.sum  s^     	F#"&&JJJJ
 446&ID 5 
 	
r\   c                   t        j                  d|       t        j                  | j                  | j
                  |||      }| j                  d||||      S )Nr   r  r  )r   validate_prodr7   r  rP   rR   r  r  s         rZ   r  zBaseMaskedArray.prod  s`     	V$"''JJJJ
 44F6YT 5 
 	
r\   r  c                   t        j                  d|       t        j                  | j                  | j
                  ||      }| j                  d|||      S )Nr   r  r  )r   validate_meanr7   r  rP   rR   r  rg   r  r   r   rY   s        rZ   r  zBaseMaskedArray.mean  sR    
V$"''JJJJ	
 **66&t*TTr\   r   r  r   ddofc                   t        j                  d|d       t        j                  | j                  | j
                  |||      }| j                  d|||      S )Nr   r  fnamer  r  )r   validate_stat_ddof_funcr7   r  rP   rR   r  rg   r  r   r  r   rY   s         rZ   r  zBaseMaskedArray.var  Y     	""2vU;"&&JJJJ
 **5&d*SSr\   c                   t        j                  d|d       t        j                  | j                  | j
                  |||      }| j                  d|||      S )Nr   r  r  r  r  )r   r  r7   r  rP   rR   r  r  s         rZ   r  zBaseMaskedArray.std+  r  r\   c                   t        j                  d|       t        j                  | j                  | j
                  ||      }| j                  d|||      S )Nr   r  r  )r   validate_minr7   r  rP   rR   r  r  s        rZ   r  zBaseMaskedArray.min8  P    
F#"&&JJJJ	
 **5&d*SSr\   c                   t        j                  d|       t        j                  | j                  | j
                  ||      }| j                  d|||      S )Nr   r  r  )r   validate_maxr7   r  rP   rR   r  r  s        rZ   r  zBaseMaskedArray.maxB  r  r\   c                :    t        | j                         ||      S )N)	na_action)r3   r   )rg   mapperr  s      rZ   mapzBaseMaskedArray.mapL  s    &IFFr\   c               d   t        j                  d|       | j                  j                         }t	        j
                  || j                  | j                         |j                         }|r|S |s(t        |       dk(  s| j                  j                         s|S | j                  j                  S )aY  
        Return whether any element is truthy.

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

        .. versionchanged:: 1.4.0

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

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

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

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

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

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

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        r   r   )r   validate_anyrP   rf   r_   putmaskrR   _falsey_valuer   r   ra   r   rg   r  r   r   rW   rY   s         rZ   r   zBaseMaskedArray.anyO  s    ~ 	F#" 	

64::t'9'9:MTatzz~~/?zz***r\   c               h   t        j                  d|       | j                  j                         }t	        j
                  || j                  | j                         |j                  |      }|r|S |r(t        |       dk(  s| j                  j                         s|S | j                  j                  S )aL  
        Return whether all elements are truthy.

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

        .. versionchanged:: 1.4.0

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

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

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

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

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

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

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        r   r   r   )r   validate_allrP   rf   r_   r  rR   _truthy_valuer   r   r   ra   r   r  s         rZ   r   zBaseMaskedArray.all  s    ~ 	F#" 	

64::t'9'9:&MSY!^4::>>3Czz***r\   c                  | j                   j                  dk(  rP|r5| j                  j                         }	| j                  j                         }
n| j                  }	| j                  }
nh| j                   j                  dv r8d}| j                  j                  d      }	| j                  j                         }
nt        d| j                          t        j                  |	f|d|||||
d| |s| S | j                   j                  dk(  rt        |       j                  |	|
      S ddlm}  |j                  |	|
      S )	z2
        See NDFrame.interpolate.__doc__.
        r   r  Tf8z)interpolate is not implemented for dtype=r   )r   r   r  r   limit_directionr   rX   rI   )ra   r   rP   rf   rR   r   rv   r
   interpolate_2d_inplacerr   r[   r  rJ   )rg   r   r   r  r   r  r   rf   r   r   rX   rJ   s               rZ   interpolatezBaseMaskedArray.interpolate  s     ::??c!zz(zz(zzzzZZ__$D::$$T*D::??$D%;DJJ<H  	&&
	
+!
	
 
	
 K::??c!:))$558,=,,T488r\   )r  c                   | j                   }| j                  }t        t        |      } |||fd|i|\  }}| j	                  ||      S )Nr  )rP   rR   r#  r6   r[   )rg   r  r  r   r   rX   rH  s          rZ   _accumulatezBaseMaskedArray._accumulate&  sP     zzzz)40d<6<V<
dd++r\   c          	     F   ddl m} |j                  |      } ||||      }	| j                  }
|	j                  dk7  r|
j                         }nt        j                  |t              }|dk(  r|j                  d      dv rd	|d d   |	j                  | j                  f||||
|d
|}|	j                  dk(  rH|	j                  j                  |	j                  d      }t        j                  ||df      j                  }|	j                  dv r|S | j!                  ||      S )Nr   )WrappedCythonOp)howr   has_dropped_na	aggregatero   rank	na_option)topbottomF)r  ngroupscomp_idsrX   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsr  get_kind_from_howrR   r   rf   r_   r!  ru   r  _cython_op_ndim_compatrP   r  _cython_aritytiler   r   )rg   r  r  r  r  idsr   r  r   rH  rX   r  
res_valuesaritys                 rZ   _groupby_opzBaseMaskedArray._groupby_op4  s    	<0054O zz77k!))+K((7$7K&=VZZ48II"KN.R..JJ
#
 

 66V$$((3E''+qz:<<K66)) **:{CCr\   )rW   rO   rX   rQ   returnr   )F)rW   rO   rX   rQ   rf   ru   r  None)rf   ru   r  r   )rd   r   ra   r!   )rz   ru   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'] | Nonerf   ru   r  r   )NNNT)r   r  rf   ru   r  r   )ra   r   rf   ru   r  ztuple[np.ndarray, np.ndarray])r  r  )r  ru   )r  rB   )r  int)r  r   )r  r   )r   )r   r   r  r   )r   r  )r  rO   )ra   znpt.DTypeLike | Nonerf   ru   r   r   r  rO   ).)ra   znpt.DTypeLikerf   ru   r  rO   )ra   r!   rf   ru   r  r;   )ra   r   rf   ru   r  r   )T)NN)ra   zNpDtype | Nonerf   zbool | Noner  rO   )r'  znp.ufuncr   ry   rT   )rX   znpt.NDArray[np.bool_] | Noner  rQ   )r  rF   )rY   z*np.ndarray | tuple[np.ndarray, np.ndarray]rX   rO   )r]  zSequence[Self]r   r   r  r   )r`  ry   ra  ry   rb  ru   r  znpt.NDArray[np.uint64])rf  ru   rg  zScalar | Noner   r   r  r   )rW   r   r  rF   )r   )rr  zLiteral['first', 'last', False]r  rQ   )r  N)r   z$NumpyValueArrayLike | ExtensionArrayrz  zLiteral['left', 'right']r{  zNumpySorter | Noner  znpt.NDArray[np.intp] | np.intp)r~  ru   r  z!tuple[np.ndarray, ExtensionArray])r  ru   r  rD   )r  ru   r  r   )r  znpt.NDArray[np.float64]r  ry   r  rM   )r  ry   r  ru   r  ru   )r  ry   )r  ru   r  r  r   AxisInt | None)r  ru   r   r  )r  ru   r   r  r  r  )r   r   r   r  rf   ru   r  rJ   )r  ry   r  ru   r  rM   )
r  ry   r  ru   r  r  r  r  r  znpt.NDArray[np.intp])[r?  
__module____qualname____doc____annotations__r   r  r  classmethodr[   rh   rm   r   r;   rw   r{   propertyra   r   r   r   r   rk   r   r   r   r   r   rd   r   r   r   r   r   r   r   r   r   r   r   r   r	   r  r   r   r   __array_priority__r  r*  r.  r   r2  rL  _logical_methodrQ  r   r+   r&  rZ  r^  re  r5   r2   rf   rt  rx  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r   r  r  r  __classcell__)r   s   @rZ   rM   rM   l   s    !    MM  MR (=EI	& .2 ! ! 			   	 ( (    
;  !:>* * 	*
 8* * 
*X 			NR.8GK	  B 6;'''/3'	&' '
O6"/       ,
,
,
& < <BF@@D
.
 '+>>	[#[ [ 	[
 
[z 			K  K      ,\  AE5#52=5	56 %$K'Z@    0	 [5z $O&6P-@-HR-^! # # 5 5  !  
	 *-;?	 !$( . 	 .
 " .  . 
 .H6(,
 		"	"#6=>3>	> $>	/ 		$	$% *0%)	H3H 'H #	H
 
(H &H  		!	!" !%"!"! 
+"! #"!H 		+	+, -&BP( 			P  P';)';:=';	';Z ,0%$(;?4	9&SS  
 
 	

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

 
* &*! U !%QATT,:TFIT !%QATT,:TFIT %) T %) TG %) O+b %) P+d29 #29 	29 29 
29j ,0	,	,$(	,		,-D -D 	-D
 -D -D "-Dr\   rM   c                   t        |       } | d   j                  }| D cg c]  }|j                  j                  dd        }}t	        j
                  |dt	        j                  t        |       t        | d         fd|j                              }| D cg c]  }|j                  j                  dd        }}t	        j
                  |dt	        j                  |t                    }|j                         }g }t        |j                  d         D ]+  }	 ||dd|	f   |dd|	f   	      }
|j                  |
       - |S c c}w c c}w )
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)orderra   )r   r  ro   Nr  )listra   rP   r   r_   r\  rq   r   r  rR   
empty_likeru   r  r   rd   r"  )masked_arraysra   r  rW   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs              rZ   #transpose_homogeneous_masked_arraysr.  d  sI    'M!""E2?@3cii2&@F@HH]1%5!67##
 2??#SYYq"%?E?~~A2==):$G ))+H/1$**1-. 1!"3AqD"9@PQRTUQU@VW  01 - A @s   #E#E)r'  zSequence[BaseMaskedArray]r  zlist[BaseMaskedArray])l
__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._exceptionsr   pandas.util._validatorsr    pandas.core.dtypes.baser!   pandas.core.dtypes.commonr"   r#   r$   r%   r&   r'   pandas.core.dtypes.dtypesr(   pandas.core.dtypes.missingr)   r*   r+   r,   pandas.corer-   rs  r.   r/   r0   pandas.core.algorithmsr1   r2   r3   r4   r5   pandas.core.array_algosr6   r7    pandas.core.array_algos.quantiler8   pandas.core.arrayliker9   pandas.core.arrays._utilsr:   pandas.core.arrays.baser;   pandas.core.constructionr<   rA  r=   r>   pandas.core.indexersr?   pandas.core.opsr@   pandas.core.util.hashingrA   collections.abcrB   rC   r  rD   r  rF   rG   rH   rJ   pandas.compat.numpyrK   r   rM   r.  r   r\   rZ   <module>rK     s    "    3     . ' 4 : 2  6    @ * > 2 
 5 . / / 1 .uDh uDp/!,!!r\   