
    Eg*                    H   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,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z;m<Z<mZm=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ er"d dl[m\Z\m]Z] d dl^m_Z_ d dl`maZa d dlmbZbmcZc d dl`mdZd d dlemfZg  G d  d!eKeO          Zhd'd&ZidS )(    )annotations)TYPE_CHECKINGAnyCallableLiteraloverloadN)libmissing)is_supported_dtype)	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSelfSequenceIndexerShapenpt)IS64is_platform_windowsAbstractMethodError)doc)validate_fillna_kwargs)ExtensionDtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker
   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexer)invalid_comparison)
hash_array)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLikeFloatingArray)functionc                      e Zd ZU dZded<   ded<   ded<   eZeZedd            Z		 dddZ
eddddd            Ze eej                  dd                        ZdddZedd            Zedd"            Zedd$            Zdd'Zddd(d)dd0Z eej                  	 ddd1            Zedd2dd5            Zd6 Zdd7Zdψ fd8Zdd:Zdd<Zedd=            Zedd>            Zdd?ZdddCZddDZ ddEZ!eddF            Z"dddHZ#ddIZ$ddJZ%ddKZ&ddLZ'ddMZ(dde)j*        fddQZ+ eej,                  dR             Z,edddU            Z-edddW            Z-edddZ            Z-ddd[Z-d\Z.ddd^Z/d_ed`<   dddZ0ddeZ1eddf            Z2ddhZ3di Z4e4Z5ddkZ6ddnZ7ddoZ8edp             Z9eddq            Z:e	 dddt            Z;ddyZ<ddd@dzdd~Z=ddZ>ddZ? eej@                  	 ddd            Z@ddZA eejB                  	 	 ddd            ZB eejC                  	 ddd            ZC eejD                  dd            ZDdddZEdddZF eejG                  dd            ZGddZHd(ddddZIddZJd ZKddZLd(d@d@dddZMd(d@d@dddZNd(d@dddZOd(d@ddddZPd(d@ddddZQd(d@dddZRd(d@dddZSddZTd(d@dddZUd(d@dddZVddZWd(dddZXdd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_]_maskvaluesmaskreturnr   c                V    t                               |           }||_        ||_        |S N)rL   __new__rO   rQ   )clsrR   rS   results       N/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/arrays/masked.py_simple_newzBaseMaskedArray._simple_new|   s(     ((--    FcopyboolNonec                0   t          |t          j                  r|j        t          j        k    st          d          |j        |j        k    rt          d          |r(|                                }|                                }|| _	        || _
        d S )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
ValueErrorr]   rO   rQ   )selfrR   rS   r]   s       rZ   __init__zBaseMaskedArray.__init__   s     4,, 	rx1G1G2   <4:%%ABBB 	[[]]F99;;D



r\   Nrd   r]   c               P    |                      |||          \  }} | ||          S )Nrk   )_coerce_to_array)rX   scalarsrd   r]   rR   rS   s         rZ   _from_sequencezBaseMaskedArray._from_sequence   s2    ++G5t+LLs64   r\   rg   r   rd   r    c                   t          j        ||j                  }|                    | j                   t          j        |t                    } | ||          }t          ||           r||j        k    rt          d| d          |S )Nrd   z5Default 'empty' implementation is invalid for dtype='')
rb   emptytypefillrM   onesr^   ra   rd   NotImplementedError)rX   rg   rd   rR   rS   rY   s         rZ   _emptyzBaseMaskedArray._empty   s     %uz222C,---wuD)))VT""&#&& 	%6<*?*?%PPPP   r\   boxedCallable[[Any], str | None]c                    t           S rV   )str)ri   ry   s     rZ   
_formatterzBaseMaskedArray._formatter   s    
r\   r'   c                     t          |           rV   r   ri   s    rZ   rd   zBaseMaskedArray.dtype   s    !$'''r\   itemr   r   c                    d S rV    ri   r   s     rZ   __getitem__zBaseMaskedArray.__getitem__       r\   r   c                    d S rV   r   r   s     rZ   r   zBaseMaskedArray.__getitem__   r   r\   r   
Self | Anyc                    t          | |          }| j        |         }t          |          r|r| j        j        S | j        |         S |                     | j        |         |          S rV   )r>   rQ   r!   rd   na_valuerO   r[   )ri   r   newmasks      rZ   r   zBaseMaskedArray.__getitem__   sj    "4..*T"7 	$ +z**:d##
4 0':::r\   T)limit
limit_arear]   methodr   r   
int | Noner   #Literal['inside', 'outside'] | Nonec               H   | j         }|                                rlt          j        || j                  }| j        j        }|j        }|r)|                                }|                                }n||                                } ||||           ||                                s|j        }| }	|		                                }
t          |	          |	d d d         	                                z
  dz
  }|dk    r;|d |
xx         |d |
         z  cc<   ||dz   d xx         ||dz   d          z  cc<   n&|dk    r ||
dz   |xx         ||
dz   |         z  cc<   |r |                     |j        |j                  S | S |r|                                 }n| }|S )Nndimr   rS      insideoutside)rQ   anyr
   get_fill_funcr   rO   Tr]   allargmaxlenr[   )ri   r   r   r   r]   rS   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                rZ   _pad_or_backfillz BaseMaskedArray._pad_or_backfill   s    z88:: 	"(di@@@Dz|HvH ##==??#==??'yy{{DX6666%dhhjj%v 5 ))8}}x"~'<'<'>'>>B))VeV$$$VeV4$$$TAXZZ(((D,<<((((9,,UQY-...$uqy47G2HH... ''
HJ??? "!YY[[

!
r\   c                H   t          ||          \  }}| j        }t          j        ||t	          |                     }|                                r|t          j        || j                  }| j        j	        }|j	        }|r(|
                                }|
                                } ||||           |                     |j	        |j	                  S |r| 
                                }	n
| d d          }	||	|<   n!|r| 
                                }	n
| d d          }	|	S )Nr   r   )r   rQ   r
   check_value_sizer   r   r   r   rO   r   r]   r[   )
ri   valuer   r   r]   rS   r   r   r   r   s
             rZ   fillnazBaseMaskedArray.fillna   s%    /uf==vz(c$ii@@88:: 	%!,V$)DDD:<6 /'}}H'}}HXU::::''
HJ???  )!%JJ!%aaaJ#(
4   %!YY[[

!!!!W
r\   r]   r   tuple[np.ndarray, np.ndarray]c                    t          |           rV   r   )rX   rR   rd   r]   s       rZ   rm   z BaseMaskedArray._coerce_to_array  s     "#&&&r\   c                   | j         j        }|dk    rt          j        |          r|S no|dk    r+t          j        |          st          j        |          r|S n>t          j        |          s(t          j        |          r|                                r|S t          dt          |           d| j                    )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        bfzInvalid value 'z' for dtype )rd   kindr	   r!   
is_integeris_floatrf   r|   )ri   r   r   s      rZ   _validate_setitem_valuez'BaseMaskedArray._validate_setitem_value  s     z3;;{5!!  S[[~e$$ U(;(;  ~e$$ e)<)< AQAQASAS 
 N#e**NN$*NNOOOr\   c                @   t          | |          }t          |          rKt          || j                  rd| j        |<   n)|                     |          }|| j        |<   d| j        |<   d S |                     || j                  \  }}|| j        |<   || j        |<   d S )NTFrq   )r>   r$   r)   rd   rQ   r   rO   rm   )ri   keyr   rS   s       rZ   __setitem__zBaseMaskedArray.__setitem__3  s    !$,,U 	$UDJ77 ("&
344U;;"'
3"'
3F++E+DDt
3
3r\   c                n   t          |          rx|| j        j        urj| j        j        j        dk    rUt          j        |          rAt          t          j	        | j                  | j
         z                                            S t          t                                          |                    S )Nr   )r*   rd   r   rO   r   r	   r   r^   rb   isnanrQ   r   super__contains__)ri   r   	__class__s     rZ   r   zBaseMaskedArray.__contains__D  s    99 	HDJ$777z$++S0A0A+RXdj11TZK?DDFFGGGEGG((--...r\   rA   c              #    K   | j         dk    rP| j        s| j        D ]}|V  d S | j        j        }t          | j        | j                  D ]\  }}|r|V  |V  d S t          t          |                     D ]}| |         V  d S )Nr   )	r   _hasnarO   rd   r   ziprQ   ranger   )ri   valr   isna_is        rZ   __iter__zBaseMaskedArray.__iter__L  s      9>>; 	":  CIIII   :."%dj$*"="= " "JE3 "&!					" " 3t99%%  1g r\   intc                *    t          | j                  S rV   )r   rO   r   s    rZ   __len__zBaseMaskedArray.__len__\  s    4:r\   c                    | j         j        S rV   )rO   rg   r   s    rZ   rg   zBaseMaskedArray.shape_  s    zr\   c                    | j         j        S rV   )rO   r   r   s    rZ   r   zBaseMaskedArray.ndimc  s    zr\   c                    | j                             ||          }| j                            ||          }|                     ||          S rV   )rO   swapaxesrQ   r[   )ri   axis1axis2datarS   s        rZ   r   zBaseMaskedArray.swapaxesg  sF    z""5%00z""5%00d+++r\   r   axisr   c                    t          j        | j        ||          }t          j        | j        ||          }|                     ||          S Nr   )rb   deleterO   rQ   r[   )ri   locr   r   rS   s        rZ   r   zBaseMaskedArray.deletel  sH    ySt444ySt444d+++r\   c                v     | j         j        |i |} | j        j        |i |}|                     ||          S rV   )rO   reshaperQ   r[   ri   argskwargsr   rS   s        rZ   r   zBaseMaskedArray.reshapeq  sJ    !tz!42622!tz!42622d+++r\   c                |     | j         j        |i |} | j        j        |i |} t          |           ||          S rV   )rO   ravelrQ   rt   r   s        rZ   r   zBaseMaskedArray.ravelv  sL    tz000tz000tDzz$%%%r\   c                V    |                      | j        j        | j        j                  S rV   )r[   rO   r   rQ   r   s    rZ   r   zBaseMaskedArray.T|  s     
djl;;;r\   decimalsc                    | j         j        dk    r| S t          j        ||           t	          j        | j        fd|i|}|                     || 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   r   )
rd   r   nvvalidate_roundrb   roundrO   _maybe_mask_resultrQ   r]   )ri   r   r   r   rR   s        rZ   r   zBaseMaskedArray.round  sm    0 :?c!!K
$'''$*BBxB6BB &&vtz/@/@AAAr\   c                h    |                      | j         | j                                                  S rV   r[   rO   rQ   r]   r   s    rZ   
__invert__zBaseMaskedArray.__invert__  (    TZ__->->???r\   c                h    |                      | j         | j                                                  S rV   r   r   s    rZ   __neg__zBaseMaskedArray.__neg__  r   r\   c                *    |                                  S rV   r   r   s    rZ   __pos__zBaseMaskedArray.__pos__  s    yy{{r\   c                    |                      t          | j                  | j                                                  S rV   )r[   absrO   rQ   r]   r   s    rZ   __abs__zBaseMaskedArray.__abs__  s,    DJ1B1BCCCr\   c                8    t          j        | t                    S )Nrq   )rb   asarrayobjectr   s    rZ   _values_for_jsonz BaseMaskedArray._values_for_json  s    z$f----r\   npt.DTypeLike | Noner   r   c                d   | j         }t          | |||          \  }}|t          }|r|t          k    r0t          |          s!|t          j        u rt          d| d          t          j                    5  t          j	        dt                     | j                            |          }ddd           n# 1 swxY w Y   ||| j        <   nbt          j                    5  t          j	        dt                     | j                            ||          }ddd           n# 1 swxY w Y   |S )aF  
        Convert to a NumPy Array.

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

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

        Returns
        -------
        numpy.ndarray

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

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

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

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

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

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

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

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.ignorecategoryr   )r   r9   r   r%   
libmissingNArh   warningscatch_warningsfilterwarningsRuntimeWarningrO   astyperQ   )ri   rd   r]   r   hasnar   s         rZ   to_numpyzBaseMaskedArray.to_numpy  s   D 24%PPx=E 	;'..  
-- &% & & &   (** 0 0'>JJJJz((//0 0 0 0 0 0 0 0 0 0 0 0 0 0 0  (D(** ; ;'>JJJJz((T(::; ; ; ; ; ; ; ; ; ; ; ; ; ; ; s$   66B88B<?B<!8D%%D),D)c                    | j         dk    rd | D             S | j        rd n| j        j        }|                     |t
          j                                                  S )Nr   c                6    g | ]}|                                 S r   )tolist.0xs     rZ   
<listcomp>z*BaseMaskedArray.tolist.<locals>.<listcomp>  s     ---1AHHJJ---r\   rd   r   )r   r   rO   rd   r   r   r   r  ri   rd   s     rZ   r  zBaseMaskedArray.tolist  sZ    9q==------9)9}}5:=}AAHHJJJr\   .npt.DTypeLikec                    d S rV   r   ri   rd   r]   s      rZ   r   zBaseMaskedArray.astype  r   r\   r:   c                    d S rV   r   r
  s      rZ   r   zBaseMaskedArray.astype  r   r\   r   r   c                    d S rV   r   r
  s      rZ   r   zBaseMaskedArray.astype   r   r\   c                   t          |          }|| j        k    r|r|                                 S | S t          |t                    rt          j                    5  t          j        dt                     | j	        
                    |j        |          }d d d            n# 1 swxY w Y   || j	        u r| j        n| j                                        }|                                } |||d          S t          |t                    r,|                                }|                    | ||          S |j        dk    rt"          j        }n,|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          |                     |||          }|S )Nr   r   r   Frk   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)rd   r   r]   )r&   rd   r]   ra   r'   r   r   r   r   rO   r   numpy_dtyperQ   construct_array_typer    ro   r   rb   nan
datetime64r	   
no_defaultr   rh   r   )ri   rd   r]   r   rS   rX   eaclsr   s           rZ   r   zBaseMaskedArray.astype$  s    U##DJ #yy{{"K e_-- 
	/(** G G'>JJJJz(():(FFG G G G G G G G G G G G G G G "&!3!34::9J9JD,,..C3tT....e^,, 	F..00E''E'EEE
 :vHHZ3}U++HH~H :$+;<<<:?@@@}}58$}GGs   =B$$B(+B(i  NpDtype | Nonec                .    |                      |          S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rq   )r   r  s     rZ   	__array__zBaseMaskedArray.__array__T  s    
 }}5})))r\   ztuple[type, ...]_HANDLED_TYPESufuncnp.ufuncr|   c                @  	
 |                     dd          }||z   D ])}t          || j        t          fz             s	t          c S *t          j        | ||g|R i |}|t          ur|S d|v rt          j        | ||g|R i |S |dk    r"t          j        | ||g|R i |}|t          ur|S t          j
        t          |           t                    	g }|D ]Q}t          |t                    r%	|j        z  	|                    |j                   <|                    |           Rd
	fd
 t!          ||          |i |}|j        dk    rt%          
fd	|D                       S |dk    r"| j                                        r| j        S |S  
|          S )Noutr   reducerq   r  rN   c                   ddl m}m}m} | j        j        dk    r                                 } || |          S | j        j        dv r                                 } || |          S | j        j        dk    rT                                }| j        t          j        k    r| 	                    t          j
                  }  || |          S t          j        | <   | S )Nr   )rE   rI   IntegerArrayr   r  r   )pandas.core.arraysrE   rI   r!  rd   r   r]   rb   float16r   float32r  )r  rE   rI   r!  mrS   s        rZ   reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s              w|s""IIKK#|Aq)))%%IIKK#|Aq)))$$IIKK7bj(( ,,A$}Q***&$Hr\   r   c              3  .   K   | ]} |          V  d S rV   r   )r  r  r&  s     rZ   	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s+      88AQ888888r\   )r  rN   )getra   r  rL   NotImplementedr-   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncrb   zerosr   r^   rQ   appendrO   getattrnouttupler   	_na_value)ri   r  r   inputsr   r  r  rY   inputs2rS   r&  s            @@rZ   __array_ufunc__zBaseMaskedArray.__array_ufunc__]  sQ    jj### 	& 	&Aa!47I!IJJ &%%%%& <%
"(
 
 
,2
 
 ''MF??4eV&,  06   X7eV&,  06 F ^++xD		... 	" 	"A!_-- "qw''''q!!!!	 	 	 	 	 	4 ('';F;;:>>8888888888xz~~ &~%M;v&&&r\   c                N    ddl }|                    | j        | j        |          S )z6
        Convert myself into a pyarrow Array.
        r   N)rS   rt   )pyarrowr;   rO   rQ   )ri   rt   pas      rZ   __arrow_array__zBaseMaskedArray.__arrow_array__  s,     	xx
$x???r\   c                4    | j                                         S rV   )rQ   r   r   s    rZ   r   zBaseMaskedArray._hasna  s     z~~r\   npt.NDArray[np.bool_] | Nonec                    |o| j                                         }|t          j        u r|dz  }nLt	          |          r2t          |          t          |          k    r|t          |          z  }n
| j         |z  }|S )NT)rQ   r]   r   r   r#   r   r*   )ri   rS   others      rZ   _propagate_maskzBaseMaskedArray._propagate_mask  s|     <:??$$D
%%d{e$$ *Us4yy)@)@d5kk):$D r\   c                   |j         }d }t          |d          sOt          |          r@t          |          t          |           k    r t	          |          }t          |d          }t          |t                    r|j        |j	        }}nRt          |          rCt          |t                    st          j        |          }|j        dk    rt          d          t          j        |t          |           f          }t          j        |          }t%          |          }|dv r)t          |t          j                  rt)          |          }|                     ||          }|t,          j        u rt          j        | j                  }| j        j        dk    r6|dv rt          d	| d
          |dv rd}nd}|                    |          }nd|v r/| j        j        dk    r|                    t          j                  }nR| j        j        dv r|dv r|}t          j        d          5   || j        |          }d d d            n# 1 swxY w Y   |dk    rrt          j        | j        dk    | j	         z  d|          }|t          j        |dk    | z  d|          }n|t,          j        urt          j        |dk    d|          }nw|dk    rq|t          j        |dk    | z  d|          }n(|t,          j        urt          j        |dk    d|          }t          j        | j        dk    | j	         z  d|          }|                     ||          S )Nrd   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   rC  rD  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8r^   rE  r   r  )rF  rI  r   )r   rC  Fr   rD  ) __name__hasattrr#   r   pd_arrayr=   ra   rL   rO   rQ   r:   rb   r   r   rw   r/   maybe_prepare_scalar_for_opget_array_opr<   re   r^   r?  r   r   	ones_likerd   r   r   float64errstatewherer   )	ri   r>  opop_nameomaskpd_oprS   rY   rd   s	            rZ   _arith_methodzBaseMaskedArray._arith_method  s   + w''	=U##	= E

c$ii'' UOOE!%t<<<Ee_-- 	V ;5EE%   	Ve^44 *
5))zA~~)*TUUU /D		|DD $$.u55o%%*UBH*E*E% KKE##E511JM!!\$*--Fz#%%    .OWOOO   o--"EE"Eu--g%%$*/S*@*@  rz22 z$&&76I+I+I *** 2 2tz5112 2 2 2 2 2 2 2 2 2 2 2 2 2 2 e8TZ1_;UDIID x!v 5udCCjm++x
E488 x!v 5udCCjm++x
E4888TZ1_;UDIID&&vt444s   2IIIrE   c                j   ddl m} d }t          |t                    r|j        |j        }}nlt          |          r]t          j        |          }|j	        dk    rt          d          t          |           t          |          k    rt          d          |t          j        u rAt          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
|j         d
          } ||          }|t2          u rt5          | j        ||          }d d d            n# 1 swxY w Y   |                     ||          } |||d          S )Nr   rD   r   rB  zLengths must match to comparer^   rq   r   elementwise__Fr   )r"  rE   ra   rL   rO   rQ   r#   rb   r   r   rw   r   rh   r   r   r.  rg   rv   r   r   r   FutureWarningDeprecationWarningr0  rL  r*  r?   r?  )ri   r>  rU  rE   rS   rY   r   s          rZ   _cmp_methodzBaseMaskedArray._cmp_method*  s   333333e_-- 	B+u{4EE%   	BJu%%EzA~~)*TUUU4yyCJJ&& !@AAAJM!!
 Xdj.f===F74:+6:::DD(** G G '-OOO'-ASTTT -A"+-A-A-ABB^++/
E2FFFG G G G G G G G G G G G G G G ##D%00|FDu5555s   ;A?FF
F
rY   *np.ndarray | tuple[np.ndarray, np.ndarray]c                   t          |t                    r1|\  }}|                     ||          |                     ||          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          ret          |j                  rQdd	lm} |j                            d
          ||<   t          ||          s|                    ||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   rH   Fr   r   rD   r%  )TimedeltaArrayr  rq   r  r!  )ra   r2  r   rd   r   r"  rI   rE   r	   is_np_dtyper   rb  rt   r[   r!  rb   r  )	ri   rY   rS   divrI  rI   rE   rb  r!  s	            rZ   r   z"BaseMaskedArray._maybe_mask_resultR  s    fe$$ 	HC''T22''T22 
 <##888888 =E::::\#%%777777<59999_V\3// 	4Fv|4T4T 	999999!<,,U33F4Lfn55 N%11&1MMMM\$&&777777<59999 6F4LMr\   c                4    | j                                         S rV   )rQ   r]   r   s    rZ   r*   zBaseMaskedArray.isna  s    z   r\   c                    | j         j        S rV   r  r   s    rZ   r3  zBaseMaskedArray._na_value  s    z""r\   c                4    | j         j        | j        j        z   S rV   )rO   nbytesrQ   r   s    rZ   ri  zBaseMaskedArray.nbytes  s    z 4:#444r\   	to_concatSequence[Self]c                    t          j        d |D             |          }t          j        d |D             |          } | ||          S )Nc                    g | ]	}|j         
S r   rO   r  s     rZ   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>      :::1qw:::r\   r   c                    g | ]	}|j         
S r   )rQ   r  s     rZ   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>  ro  r\   )rb   concatenate)rX   rj  r   r   rS   s        rZ   _concat_same_typez!BaseMaskedArray._concat_same_type  sZ     ~::	:::FFF~::	:::FFFs4r\   encodinghash_key
categorizenpt.NDArray[np.uint64]c                   t          | j        |||          }t          | j        j                  ||                                 <   |S )N)rs  rt  ru  )r@   rO   hashrd   r   r*   )ri   rs  rt  ru  hashed_arrays        rZ   _hash_pandas_objectz#BaseMaskedArray._hash_pandas_object  sJ     "JH
 
 
 %))<$=$=TYY[[!r\   )
allow_fill
fill_valuer   r{  r|  Scalar | Nonec               (   t          |          r| j        n|}t          | j        ||||          }t          | j        |d||          }|r1t          |          r"t          j        |          dk    }|||<   ||z  }|                     ||          S )N)r|  r{  r   Tr   )	r*   rM   r4   rO   rQ   r+   rb   r   r[   )	ri   indexerr{  r|  r   data_fill_valuerY   rS   	fill_masks	            rZ   r4   zBaseMaskedArray.take  s     8<J7G7GW$33ZJ&!
 
 
 JDZd
 
 
  	$%
++ 	$
7++r1I *F9)#D---r\   c                @    ddl m} t          j        |          }t	           j        |          } j        r5|j        t          k    ot           fd|D                       }|| j
        <   t          j         j        j        t                    } |||d          S )Nr   rD   c              3  4   K   | ]}|j         j        u V  d S rV   r  )r  r   ri   s     rZ   r(  z'BaseMaskedArray.isin.<locals>.<genexpr>  sF       @ @/2tz**@ @ @ @ @ @r\   rq   Fr   )r"  rE   rb   r   r1   rO   r   rd   r   r   rQ   r.  rg   r^   )ri   rR   rE   
values_arrrY   values_have_NArS   s   `      rZ   r1   zBaseMaskedArray.isin  s    333333 Z''
dj*--; 	0'-7 C @ @ @ @6@@ @ @ = =N "0F4:x
(555|FDu5555r\   c                    | j                                         }| j                                        }|                     ||          S rV   )rO   r]   rQ   r[   )ri   r   rS   s      rZ   r]   zBaseMaskedArray.copy  s:    z  z  d+++r\   r   keepLiteral['first', 'last', False]c                L    | j         }| j        }t          j        |||          S )N)r  rS   )rO   rQ   algos
duplicated)ri   r  rR   rS   s       rZ   r  zBaseMaskedArray.duplicated  s*     zT====r\   c                r    t          j        | j        | j                  \  }}|                     ||          S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )r  unique_with_maskrO   rQ   r[   )ri   uniquesrS   s      rZ   uniquezBaseMaskedArray.unique  s4     .tz4:FF...r\   leftr   $NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterNumpySorter | Nonenpt.NDArray[np.intp] | np.intpc                    | j         rt          d          t          |t                    r|                    t
                    }| j                            |||          S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)r  r  )r   rh   ra   r:   r   r   rO   searchsorted)ri   r   r  r  s       rZ   r  zBaseMaskedArray.searchsorted  sg     ; 	$   e^,, 	)LL((Ez&&u4&GGGr\   use_na_sentinel!tuple[np.ndarray, ExtensionArray]c                   | j         }| j        }t          |d|          \  }}|j        | j        j        k    sJ |j        | j        f            |                                }|s|st          |          }nt          |          dz   }t          j        |t                    }|s|r|
                                }	|	dk    rt          j        d          }
n|d |	                                         dz   }
|||
k    xx         dz  cc<   |
||dk    <   t          j        ||
d          }d||
<   |                     ||          }||fS )NT)r  rS   r   rq   r   r   )rO   rQ   r0   rd   r  r   r   rb   r.  r^   r   intpmaxinsertr[   )ri   r  arrrS   codesr  has_nasizeuniques_maskna_indexna_code
uniques_eas               rZ   	factorizezBaseMaskedArray.factorize   se   
 jz )dNNNw }
 6666
8S666 	$& 	$w<<DD w<<!#DxD111 	)6 	){{}}H1}}'!**		*..0014%7"###q(###!(E%2+i!44G$(L!%%g|<<
j  r\   c                    | j         S rV   rn  r   s    rZ   _values_for_argsortz#BaseMaskedArray._values_for_argsort%  s
    zr\   dropnarC   c                   ddl m}m} ddlm} t          j        | j        || j                  \  }}}t          j
        t          |          ft          j                  }|                                }	|dk    rd|d<    |||	          }
 | | 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   )IndexrC   rc  r  rS   rq   Tr   countF)indexnamer]   )pandasr  rC   pandas.arraysr!  r  value_counts_arraylikerO   rQ   rb   r.  r   re   r]   rd   r  )ri   r  r  rC   r!  keysvalue_counts
na_counter
mask_indexrS   r  r  s               rZ   r  zBaseMaskedArray.value_counts)  s
   "	
 	
 	
 	
 	
 	
 	
 	
 	/.....).)EJvDJ*
 *
 *
&lJ Xs<002"(CCC
  >>!JrNl<..-DJ++--j 
 

 vcW5AAAAr\   c                .   |rBt          | j        || j                  }t          j        |j        t          j                  }nt          | j        || j                  \  }} t          |           ||          }||                                         S )Nr  rq   )	r3   rO   rQ   rb   r.  rg   re   rt   argsort)ri   r  rY   res_masks       rZ   _modezBaseMaskedArray._modeQ  s     	P$*V$*EEEFxBH===HH#DJvDJOOOFHdFH--fnn&&''r\   c                   t          |           t          |          k    rdS |j        | j        k    rdS t          j        | j        |j                  sdS | j        | j                  }|j        |j                  }t          ||dd          S )NFT)
strict_nandtype_equal)rt   rd   rb   array_equalrQ   rO   r(   )ri   r>  r  rights       rZ   equalszBaseMaskedArray.equalsZ  s    ::e$$5;$*$$5 ~dj%+66 	5z4:+&U[L)e$OOOOr\   qsnpt.NDArray[np.float64]interpolationc                4   t          | j        | j        t          j        ||          }| j        r| j        dk    rt          |                                 	                                rZt          j
        |j        t                    }t          | j                  r%t          j        |j        | j        j                  }nAt          j        |j        t                    }n t          j        |j        t                    }|                     ||          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.
        )rS   r|  r  r     rq   rS   )r7   rO   rQ   rb   r  r   r   rw   r*   r   rv   rg   r^   r"   rd   r.  r  r   )ri   r  r  resout_masks        rZ   	_quantilezBaseMaskedArray._quantilej  s     !J v'
 
 
 ; 	7 yA~~ *)yy{{   ;739D999#DJ// L (39DJ4JKKKC8CIT:::x	666H&&s&:::r\   )skipnakeepdimsr  r  r  c                  |dv r t          | |          dd|i|}nI| j        }| j        }t          t          d|           }|                    dd           }	 ||f|	||d|}|rmt          |          r|                     |dd          S |                    d	          }t          j	        d	t          
          }|                     ||          S t          |          rt          j        S |S )N>	   r   r   r  minstdsumvarmeanprodr  r  r   )r   r  rS   r   )r   )r  r   	mask_sizer   rq   r   )r0  rO   rQ   r.   popr*   _wrap_na_resultr   rb   r.  r^   r   r   r   )
ri   r  r  r  r   rY   r   rS   rU  r   s
             rZ   _reducezBaseMaskedArray._reduce  s    TTT(WT4((AAA&AAFF :D:Dt..B::fd++DRL4TLLVLLF 	=F|| =++A+NNN**x.....vt<<<<< 	= Mr\   c                   t          |t          j                  rO|r| j                            |          }n| j                            |          }|                     ||          S |S r   )ra   rb   rc   rQ   r   r   r   )ri   r  rY   r  r   rS   s         rZ   _wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result  se    fbj)) 	9 1z~~4~00z~~4~00**648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        }n9t                      pt           }|rdnd	}|rd
nd}	|||	|d| j        j	                 }t          j
        dg|          }
|                     |
|          S )Nrq   Float32r$  rR  )r  medianr  r  skewkurt)r  r     int32int64uint32uint64)r   r   ur   r   r  )rb   rv   r^   rd   itemsizer  r  r   r   r   r;   r   )ri   r  r   r  rS   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              rZ   r  zBaseMaskedArray._wrap_na_result  s    wy---"&*	"9"9YYy
CCC!HH^##tz':a'?'?z-2HH"5"7"7"Ct8"5Bww7H$7EXI%H9:VV
H !H---&&u4&888r\   c                   |dk    rNt          |t          j                  r4|                     |t          j        |j        t                              S |                     ||||          S )Nr   rq   r  r   )ra   rb   rc   r   r.  rg   r^   r  )ri   r  rY   r  	min_countr   s         rZ    _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_result  sb     >>j<<>**628FLPT3U3U3UVVV**4T*RRRr\   r  r  r   r  AxisInt | Nonec                   t          j        d|           t          j        | j        | j        |||          }|                     d||||          S )Nr   r  r  )r   validate_sumr6   r  rO   rQ   r  ri   r  r  r   r   rY   s         rZ   r  zBaseMaskedArray.sum  sj     	F###"&JJ
 
 
 446&ID 5 
 
 	
r\   c                   t          j        d|           t          j        | j        | j        |||          }|                     d||||          S )Nr   r  r  )r   validate_prodr6   r  rO   rQ   r  r  s         rZ   r  zBaseMaskedArray.prod  sk     	V$$$"'JJ
 
 
 44F6YT 5 
 
 	
r\   r  c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_meanr6   r  rO   rQ   r  ri   r  r   r   rY   s        rZ   r  zBaseMaskedArray.mean  s[    
V$$$"'JJ	
 
 
 **66&t*TTTr\   r   r  r   ddofr  c                   t          j        d|d           t          j        | j        | j        |||          }|                     d|||          S )Nr   r  fnamer  r  )r   validate_stat_ddof_funcr6   r  rO   rQ   r  ri   r  r   r  r   rY   s         rZ   r  zBaseMaskedArray.var	  e     	"2vU;;;;"&JJ
 
 
 **5&d*SSSr\   c                   t          j        d|d           t          j        | j        | j        |||          }|                     d|||          S )Nr   r  r  r  r  )r   r  r6   r  rO   rQ   r  r  s         rZ   r  zBaseMaskedArray.std  r   r\   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_minr6   r  rO   rQ   r  r  s        rZ   r  zBaseMaskedArray.min#  Z    
F###"&JJ	
 
 
 **5&d*SSSr\   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_maxr6   r  rO   rQ   r  r  s        rZ   r  zBaseMaskedArray.max-  r  r\   c                J    t          |                                 ||          S )N)	na_action)r2   r   )ri   mapperr  s      rZ   mapzBaseMaskedArray.map7  s    &IFFFFr\   c               F   t          j        d|           | j                                        }t	          j        || j        | j                   |                                }|r|S |s,t          |           dk    s| 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_anyrO   r]   rb   putmaskrQ   _falsey_valuer   r   rd   r   ri   r  r   r   rR   rY   s         rZ   r   zBaseMaskedArray.any:  s    ~ 	F###"" 	
64:t'9::: 	+M +Tatz~~/?/?z**r\   c               J   t          j        d|           | j                                        }t	          j        || j        | j                   |                    |          }|r|S |r,t          |           dk    s| 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_allrO   r]   rb   r  rQ   _truthy_valuer   r   r   rd   r   r  s         rZ   r   zBaseMaskedArray.all  s    ~ 	F###"" 	
64:t'9:::&& 	+M +SYY!^^4:>>3C3C^z**r\   r   rI   c               0   | j         j        dk    rD|r3| j                                        }	| j                                        }
nj| j        }	| j        }
n[| j         j        dv r6d}| j                            d          }	| j                                        }
nt          d| j                    t          j        |	f|d|||||
d| |s| S | j         j        dk    r#t          |           
                    |	|
          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   rS   rH   )rd   r   rO   r]   rQ   r   rw   r
   interpolate_2d_inplacert   r[   r"  rI   )ri   r   r   r  r   r  r   r]   r   r   rS   rI   s               rZ   interpolatezBaseMaskedArray.interpolate  sN     :?c!! "z((z((zzZ_$$D:$$T**D:??$$DD%HDJHH   	&
	
+!
	
 
	
 
	
 
	
 
	
  	K:?c!!::))$555888888,=,T4888r\   )r  c                   | j         }| j        }t          t          |          } |||fd|i|\  }}|                     ||          S )Nr  )rO   rQ   r0  r5   r[   )ri   r  r  r   r   rS   rU  s          rZ   _accumulatezBaseMaskedArray._accumulate  sZ     zz)400Rd<<6<V<<
dd+++r\   howhas_dropped_nangroupsidsnpt.NDArray[np.intp]c          	     "   ddl m} |                    |          } ||||          }	| j        }
|	j        dk    r|
                                }nt          j        |t                    }|dk    r|	                    d          dv rd	|d d <    |	j
        | j        f||||
|d
|}|	j        dk    r<|	j        	                    |	j        d          }t          j        ||df          j        }|	j        dv r|S |                     ||          S )Nr   )WrappedCythonOp)r  r   r  	aggregaterq   rank	na_option)topbottomF)r  r  comp_idsrS   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsr   get_kind_from_howrQ   r   r]   rb   r.  r^   r)  _cython_op_ndim_compatrO   r  _cython_aritytiler   r   )ri   r  r  r  r  r  r   r   r   rU  rS   r'  
res_valuesaritys                 rZ   _groupby_opzBaseMaskedArray._groupby_op  sN    	<;;;;;0055_4OOO z7k!!))++KK(7$777K&==VZZ448III"KN.R.J
#
 
 
 

 6V$((33E'+qz::<K6))) **:{CCCr\   )rR   rN   rS   rP   rT   r   )F)rR   rN   rS   rP   r]   r^   rT   r_   )r]   r^   rT   r   )rg   r   rd   r    )ry   r^   rT   rz   )rT   r'   )r   r   rT   r   )r   r   rT   r   )r   r   rT   r   )
r   r   r   r   r   r   r]   r^   rT   r   )NNNT)r   r   r]   r^   rT   r   )rd   r   r]   r^   rT   r   )rT   r_   )rT   r^   )rT   rA   )rT   r   )rT   r   )rT   r   )r   )r   r   rT   r   )r   r   )rT   rN   )rd   r   r]   r^   r   r   rT   rN   ).)rd   r  r]   r^   rT   rN   )rd   r    r]   r^   rT   r:   )rd   r   r]   r^   rT   r   )TrV   )rd   r  rT   rN   )r  r  r   r|   )rS   r<  rT   rP   )rT   rE   )rY   r`  rS   rN   )rj  rk  r   r   rT   r   )rs  r|   rt  r|   ru  r^   rT   rv  )r{  r^   r|  r}  r   r   rT   r   )rR   r   rT   rE   )r   )r  r  rT   rP   )r  N)r   r  r  r  r  r  rT   r  )r  r^   rT   r  )r  r^   rT   rC   )r  r^   rT   r   )r  r  r  r|   rT   rL   )r  r|   r  r^   r  r^   )r  r|   )r  r^   r  r   r   r  )r  r^   r   r  )r  r^   r   r  r  r   )r   r   r   r   r]   r^   rT   rI   )r  r|   r  r^   rT   rL   )
r  r|   r  r^   r  r   r  r   r  r  )[rL  
__module____qualname____doc____annotations__r   r  r  classmethodr[   rj   ro   r   r:   rx   r}   propertyrd   r   r   r   r   rm   r   r   r   r   r   rg   r   r   r   r   r   r   r   r   r   r   r   r   r	   r  r   r  r   __array_priority__r  r6  r:  r   r?  rY  _logical_methodr_  r   r*   r3  ri  rr  rz  r4   r1   r]   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r
  r   r   r  r  r2  __classcell__)r   s   @rZ   rL   rL   k   s&
          !        MM   [ MR    & .2 ! ! ! ! ! [! S		 	 	   [	     ( ( ( X(    X    X
; 
; 
; 
;  !:>* * * * * *X 	S	NR     B 6;' ' ' ' ' ['
P P P6   "/ / / / / /              X     X, , , ,
, , , , ,
, , , ,
& & & & < < < X<B B B B BF@ @ @ @@ @ @ @   D D D D
. . . .
 '+>	[ [ [ [ [z 	S	K K  K     X     X     X, , , , ,\ * * * * * %$$$K' K' K' K'Z@ @ @ @       X     [5 [5 [5z $O&6 &6 &6 &6P- - - -^! ! ! ! # # X# 5 5 5 X5      [    !$( .  .  .  .  .  .H6 6 6 6(, , , ,
 	S	"##6=> > > > $#>	/ 	/ 	/ 	/ 	S	$%% *0%)	H H H H &%H  	S	!"" !%"! "! "! "! #""!H 	S	+,,   -,&B &B &B &B &BP( ( ( ( ( 	S	P P P  P'; '; '; ';Z ,0%     4	 	 	 	9 9 9&S S S S  
 
 
 
 
 
0  
 
 
 
 
 
* &*! U U U U U U !%QAT T T T T T !%QAT T T T T T %) T T T T T T %) T T T T T TG G G G %) O+ O+ O+ O+ O+ O+b %) P+ P+ P+ P+ P+ P+d29 29 29 29j ,0	, 	, 	, 	, 	, 	,-D -D -D -D -D -D -D -Dr\   rL   masked_arraysSequence[BaseMaskedArray]rT   list[BaseMaskedArray]c                F   t          |           } | d         j        }d | D             }t          j        |dt          j        t          |           t          | d                   fd|j                            }d | D             }t          j        |dt          j        |t                              }|	                                }g }t          |j        d                   D ]8} ||d	d	|f         |d	d	|f         
          }	|                    |	           9|S )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   c                D    g | ]}|j                             d d          S r   r   )rO   r   r  r  s     rZ   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>Z  s*    @@@3ci2&&@@@r\   F)orderrd   )r   r  c                D    g | ]}|j                             d d          S rA  )rQ   r   rB  s     rZ   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>e  s*    ???#SYq"%%???r\   rq   r   Nr  )listrd   rb   rq  rs   r   r  
empty_liker^   r  r   rg   r/  )
r<  rd   rR   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs
             rZ   #transpose_homogeneous_masked_arraysrN  O  sW    ''M!"E@@-@@@FH]1%5!6!67#
 
 
   @????E~A2=):$GGG   ))++H/1$*1-.. 1 1!"3AAAqD"9@PQRQRQRTUQU@VWWW  0000r\   )r<  r=  rT   r>  )j
__future__r   typingr   r   r   r   r   r   numpyrb   pandas._libsr	   r
   r   pandas._libs.tslibsr   pandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.compatr   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._validatorsr   pandas.core.dtypes.baser    pandas.core.dtypes.commonr!   r"   r#   r$   r%   r&   pandas.core.dtypes.dtypesr'   pandas.core.dtypes.missingr(   r)   r*   r+   pandas.corer,   r  r-   r.   r/   pandas.core.algorithmsr0   r1   r2   r3   r4   pandas.core.array_algosr5   r6    pandas.core.array_algos.quantiler7   pandas.core.arrayliker8   pandas.core.arrays._utilsr9   pandas.core.arrays.baser:   pandas.core.constructionr;   rN  r<   r=   pandas.core.indexersr>   pandas.core.opsr?   pandas.core.util.hashingr@   collections.abcrA   rB   r  rC   r"  rE   rF   rG   rI   pandas.compat.numpyrJ   r   rL   rN  r   r\   rZ   <module>rj     s   " " " " " "                          3 2 2 2 2 2                                        . - - - - - ' ' ' ' ' ' : : : : : : 2 2 2 2 2 2                6 5 5 5 5 5                                             @ ? ? ? ? ? * * * * * * > > > > > > 2 2 2 2 2 2         
 5 4 4 4 4 4 . . . . . . / / / / / / 1        //////        100000 . . . . . .aD aD aD aD aDh aD aD aDH/! ! ! ! ! !r\   