
    Piz                      d dl mZ d dlmZ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mZmZ d dl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&m'Z'm(Z( d dl)m*Z*m+Z+ d dl,m-Z-m.Z.m/Z/m0Z0 d dl1m2Zm3Z3mZm4Z4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z:m;Z; d dl<m=Z=m>Z> d dl?m@Z@ d dlAmBZB d dlCmDZD d dlEmFZF d dlGmHZH d dlImJZKmLZLmMZM d dlNmOZOmPZP d dlQmRZR d dlSmTZT erHd dlUmVZV d dlUmWZWmXZX d dlYmZZZ d dl[m\Z\ d dl]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZl d d lmmnZn d d!l[moZo d d"lpmqZr  G d# d$eDeH          Zsd*d)ZtdS )+    )annotations)TYPE_CHECKINGAnyLiteralSelfcastoverloadN)	is_nan_nausing_python_scalars)algoslibmissing)is_supported_dtype)IS64is_platform_windowsAbstractMethodError)astype_is_view)ExtensionDtype)maybe_downcast_to_dtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)
ArrowDtypeBaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)shift)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexergetitem_returns_view)invalid_comparison)
hash_array)Callable)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLike	ArrayLike	AstypeArgAxisIntDtypeObjFillnaOptionsInterpolateOptionsNpDtypePositionalIndexerScalarScalarIndexerSequenceIndexerShapenpt)NATypeFloatingArray)functionc                  \    e Zd ZU dZded<   ded<   edd
            Z	 dddZeddddd            ZddZ	edd            Z
dddZedd            Zedd"            Zedd$            Zdd'Zddd(d)dd0Z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dddHZeddI            ZdddKZ ddLZ!ddMZ"ddNZ#ddOZ$ddPZ%dde&j'        fddTZ(ddVZ)edddY            Z*eddd[            Z*eddd]            Z*ddd^Z*d_Z+	 dddbZ,dcedd<   ddhZ-ddiZ.eddj            Z/ddlZ0dm Z1e1Z2ddoZ3ddrZ4ddsZ5edt             Z6eddu            Z7e	 dddx            Z8dd}Z9ddd@d~ddZ:ddZ;ddZ<d@ddd(ddd dZ=	 dddZ>ddZ?	 	 dddZ@	 dddZAddZBdddZCdddZDddZEddZFd(ddd	dZGd
dZHd ZId
dZJd(d@d@dddZKd(d@d@dddZLd(d@dddZMd(d@dFdddZNd(d@dFdddZOd(d@dddZPd(d@dddZQdddZRedWdWddd            ZSedWdddÄ            ZSd(d@dddĄZSedWdWdddń            ZTedWdddƄ            ZTd(d@dddǄZTddʄZUd(d˜dd̄ZVdd҄ZW xZXS (  BaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    
np.ndarray_datanpt.NDArray[np.bool_]_maskvaluesmaskreturnr   c                V    t                               |           }||_        ||_        |S N)rT   __new__rV   rX   )clsrY   rZ   results       m/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/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
ValueErrorrd   rV   rX   )selfrY   rZ   rd   s       ra   __init__zBaseMaskedArray.__init__   s     4,, 	rx1G1G2   <4:%%ABBB 	[[]]F99;;D



rc   Nrk   rd   c               P    |                      |||          \  }} | ||          S )Nrr   )_coerce_to_array)r_   scalarsrk   rd   rY   rZ   s         ra   _from_sequencezBaseMaskedArray._from_sequence   s2    ++G5t+LLs64   rc   rB   c                   t          |                                          r)t          |                               || j                  S t          j        |t                    }t          j	        |d          }| j        j
        }|j        j
        }|dv r|dv s||cxk    rdk    rVn nSt          t          |          }t          |j        | j        j                  } t          |          ||j                  }|S )Nrk   T)convert_to_nullable_dtypeiuf)r!   alltyperv   rk   ri   asarrayobjectr   maybe_convert_objectskindr   rT   r   rV   numpy_dtyperX   )rp   rY   r`   lkindrkindnew_datas         ra   _cast_pointwise_resultz&BaseMaskedArray._cast_pointwise_result   s    << 	G::,,V4:,FFFF&111*6TRRR
!TMMetmm%1F1F1F1F31F1F1F1F1F/622F.DJ$:  H "T&\\(FL99Frc   rn   rM   rk   r   c                D   t          t          |          }t          j        ||j                  }|                    |j                   t          j        |t                    } | ||          }t          ||           r||j
        k    rt          d| d          |S )z
        Create an ExtensionArray with the given shape and dtype.

        See also
        --------
        ExtensionDtype.empty
            ExtensionDtype.empty is the 'official' public version of this API.
        rx   z5Default 'empty' implementation is invalid for dtype='')r   r   ri   emptyr}   fill_internal_fill_valueonesre   rh   rk   NotImplementedError)r_   rn   rk   rY   rZ   r`   s         ra   _emptyzBaseMaskedArray._empty   s     _e,,Xe5:>>>E.///wuD)))VT""&#&& 	%6<*?*?%PPPP   rc   boxedCallable[[Any], str | None]c                    t           S r]   )str)rp   r   s     ra   
_formatterzBaseMaskedArray._formatter   s    
rc   r   c                     t          |           r]   r   rp   s    ra   rk   zBaseMaskedArray.dtype   s    !$'''rc   itemrK   r   c                    d S r]    rp   r   s     ra   __getitem__zBaseMaskedArray.__getitem__   s    7:src   rL   c                    d S r]   r   r   s     ra   r   zBaseMaskedArray.__getitem__   s    :=#rc   rI   
Self | Anyc                   t          | |          }| j        |         }t          |          r|r| j        j        S | j        |         S |                     | j        |         |          }t          | |          r| j        |_        |S r]   )	r6   rX   r   rk   na_valuerV   rb   r7   	_readonly)rp   r   newmaskr`   s       ra   r   zBaseMaskedArray.__getitem__   s    "4..*T"7 	$ +z**:d##!!$*T"2G<<d++ 	.#~Frc   T)limit
limit_areard   methodrF   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   rZ      insideoutside)rX   anyr   get_fill_funcr   rV   Trd   r|   argmaxlenrb   )rp   r   r   r   rd   rZ   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                ra   _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??? 	JJJrc   c                   | j         }|X|t          |           k     rE|                                |k    }|                                r|                                }d||<   t          j        ||t          |                     }|                                r'|r|                                 }n
| dd         }|||<   n!|r|                                 }n
| dd         }|S )aH  
        Fill NA/NaN values using the specified method.

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

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

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

        Examples
        --------
        >>> arr = pd.array([np.nan, np.nan, 2, 3, np.nan, np.nan])
        >>> arr.fillna(0)
        <IntegerArray>
        [0, 0, 2, 3, 0, 0]
        Length: 6, dtype: Int64
        NF)rX   r   cumsumr   rd   r   check_value_size)rp   valuer   rd   rZ   modifyr   s          ra   fillnazBaseMaskedArray.fillna  s    L zT!2!2[[]]U*Fzz|| %yy{{$V(c$ii@@88:: 
	! %!YY[[

!!!!W
$Jt 	!JJaaaJrc   rd   rE   tuple[np.ndarray, np.ndarray]c                    t          |           r]   r   )r_   rY   rk   rd   s       ra   rt   z BaseMaskedArray._coerce_to_arrayM  s     "#&&&rc   c                h   | 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|d| j          d          )zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        br{   zInvalid value 'z' for dtype 'r   )rk   r   r   r   
is_integeris_floatrm   )rp   r   r   s      ra   _validate_setitem_valuez'BaseMaskedArray._validate_setitem_valueS  s     z3;;{5!!  S[[~e$$ U(;(;  ^E"" 	s|E':': 	u?O?O?Q?Q 	L
 M%MM
MMMNNNrc   c                   | j         rt          d          t          | |          }t          |          rmt	          || j                  r-t          j        |          rt                      rd| j	        |<   n)| 
                    |          }|| j        |<   d| j	        |<   d S |                     || j                  \  }}|| j        |<   || j	        |<   d S )NzCannot modify read-only arrayTFrx   )r   ro   r6   r   r    rk   r   r   r
   rX   r   rV   rt   )rp   keyr   rZ   s       ra   __setitem__zBaseMaskedArray.__setitem__m  s    > 	><===!$,,U 		$UDJ77 (U##(,5KK( #'
344U;;"'
3"'
3F++E+DDt
3
3rc   c                   t          |          r|| j        j        urt          j        |          rt                      r| j        j        }nj| j        j        j        dk    rUt          j        |          rAt          t          j
        | j                  | j         z                                            S t          t                                          |                    S )Nr{   )r!   rk   r   r   r   r
   rV   r   re   ri   isnanrX   r   super__contains__)rp   r   	__class__s     ra   r   zBaseMaskedArray.__contains__  s    99 	HDJ$777|C   HY[[ Hj)!&#--#,s2C2C-RXdj11TZK?DDFFGGGEGG((--...rc   r;   c              #    K   | j         dk    rR| j        s| j        D ]}|V  d S | j        j        }t          | j        | j        d          D ]\  }}|r|V  |V  d S t          t          |                     D ]}| |         V  d S )Nr   T)strict)	r   _hasnarV   rk   r   ziprX   ranger   )rp   valr   isna_is        ra   __iter__zBaseMaskedArray.__iter__  s      9>>; 	":  CIIII   :."%dj$*T"J"J"J " "JE3 "&!					" " 3t99%%  1g rc   intc                *    t          | j                  S r]   )r   rV   r   s    ra   __len__zBaseMaskedArray.__len__  s    4:rc   c                    | j         j        S r]   )rV   rn   r   s    ra   rn   zBaseMaskedArray.shape  s    zrc   c                    | j         j        S r]   )rV   r   r   s    ra   r   zBaseMaskedArray.ndim  s    zrc   c                    | j                             ||          }| j                            ||          }|                     ||          S r]   )rV   swapaxesrX   rb   )rp   axis1axis2datarZ   s        ra   r   zBaseMaskedArray.swapaxes  sF    z""5%00z""5%00d+++rc   r   axisrD   c                    t          j        | j        ||          }t          j        | j        ||          }|                     ||          S Nr   )ri   deleterV   rX   rb   )rp   locr   r   rZ   s        ra   r   zBaseMaskedArray.delete  sH    ySt444ySt444d+++rc   c                v     | j         j        |i |} | j        j        |i |}|                     ||          S r]   )rV   reshaperX   rb   rp   argskwargsr   rZ   s        ra   r   zBaseMaskedArray.reshape  sJ    !tz!42622!tz!42622d+++rc   c                |     | j         j        |i |} | j        j        |i |} t          |           ||          S r]   )rV   ravelrX   r}   r   s        ra   r   zBaseMaskedArray.ravel  sL    tz000tz000tDzz$%%%rc   r   periodsc                    d}|/t          | j        ||d          }t          | j        ||d          }n.t          | j        |||          }t          | j        ||d          } t          |           ||          S )Nr   TF)r/   rV   rX   r}   )rp   r   
fill_valuer   r   r   s         ra   r/   zBaseMaskedArray.shift  s{    TZ$::HTZ$==HHTZ$
CCHTZ$>>HtDzz(H---rc   c                V    |                      | j        j        | j        j                  S r]   )rb   rV   r   rX   r   s    ra   r   zBaseMaskedArray.T  s     
djl;;;rc   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   )
rk   r   nvvalidate_roundri   roundrV   _maybe_mask_resultrX   rd   )rp   r   r   r   rY   s        ra   r   zBaseMaskedArray.round  sm    0 :?c!!K
$'''$*BBxB6BB &&vtz/@/@AAArc   c                h    |                      | j         | j                                                  S r]   rb   rV   rX   rd   r   s    ra   
__invert__zBaseMaskedArray.__invert__  (    TZ__->->???rc   c                h    |                      | j         | j                                                  S r]   r   r   s    ra   __neg__zBaseMaskedArray.__neg__  r   rc   c                *    |                                  S r]   r   r   s    ra   __pos__zBaseMaskedArray.__pos__  s    yy{{rc   c                    |                      t          | j                  | j                                                  S r]   )rb   absrV   rX   rd   r   s    ra   __abs__zBaseMaskedArray.__abs__  s,    DJ1B1BCCCrc   c                8    t          j        | t                    S )Nrx   )ri   r~   r   r   s    ra   _values_for_jsonz BaseMaskedArray._values_for_json  s    z$f----rc   npt.DTypeLike | Noner   r   c                (   | j         }t          | |||          \  }}|t          j        t                    }|r|t          j        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        <   nt          j
                    5  t          j        dt                     | j                            ||          }ddd           n# 1 swxY w Y   | j        r7|s5t#          | j        |          r |                                }d|j        _        |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   F)r   r1   ri   rk   r   r   
libmissingNAro   warningscatch_warningsfilterwarningsRuntimeWarningrV   astyperX   r   r   viewflags	writeable)rp   rk   rd   r   hasnar   s         ra   to_numpyzBaseMaskedArray.to_numpy   s   D 24%PPx=HV$$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(::; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ~ -d -~dj%/P/P -yy{{',
$s$   6CC #C 8E		EElistc                    | j         dk    rd | D             S | j        rdn| j        j        }|                     |t
          j                                                  S )aF  
        Return a list of the values.

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

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

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

        Examples
        --------
        >>> arr = pd.array([1, 2, 3])
        >>> arr.tolist()
        [1, 2, 3]
        r   c                6    g | ]}|                                 S r   )tolist.0xs     ra   
<listcomp>z*BaseMaskedArray.tolist.<locals>.<listcomp>y  s     ---1AHHJJ---rc   Nrk   r   )r   r   rV   rk   r  r  r  r  )rp   rk   s     ra   r  zBaseMaskedArray.tolist`  s\    0 9q==------9)9}}5:=}AAHHJJJrc   .npt.DTypeLikec                    d S r]   r   rp   rk   rd   s      ra   r  zBaseMaskedArray.astype}  s    LOCrc   r2   c                    d S r]   r   r"  s      ra   r  zBaseMaskedArray.astype  s    QTQTrc   rC   c                    d S r]   r   r"  s      ra   r  zBaseMaskedArray.astype  s    GJsrc   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   Frr   r{   MNaTrz   zcannot convert NA to integerr   z cannot convert float NaN to bool)rk   r   rd   )r   rk   rd   rh   r   r  r  r  r  rV   r  r   rX   construct_array_typer   rv   r   ri   nan
datetime64r   
no_defaultr   ro   r  )rp   rk   rd   r   rZ   r_   eaclsr   s           ra   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 | Nonebool | Nonec                    |du r[| j         sEt          j        | j        ||          }| j        r |                                }d|j        _        |S t          d          |d}| 	                    ||          S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        Frr   z:Unable to avoid copy while creating an array as requested.)
r   ri   r3   rV   r   r  r  r  ro   r  )rp   rk   rd   r`   s       ra   	__array__zBaseMaskedArray.__array__  s     5==; $*EEEE> 3#[[]]F-2FL*L   <D}}5t}444rc   ztuple[type, ...]_HANDLED_TYPESufuncnp.ufuncr   c                B  	
 |                     dd          }||z   D ]*}t          |g | j        t          R           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   reducerx   r  rU   c                   ddl m}m}m} | j        j        dk    r                                 } || |          S | j        j        dv r                                 } || |          S | j        j        dk    ry                                }| j        t          j        k    r| 	                    t          j
                  } t                      rd|t          j        |           <    || |          S t          j        | <   | S )Nr   )r?   rQ   IntegerArrayr   rz   r{   T)pandas.core.arraysr?   rQ   r8  rk   r   rd   ri   float16r  float32r
   r   r)  )r  r?   rQ   r8  mrZ   s        ra   reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s             w|s""IIKK#|Aq)))%%IIKK#|Aq)))$$IIKK7bj(( ,,A;; *%)AbhqkkN$}Q***&$Hrc   r   c              3  .   K   | ]} |          V  d S r]   r   )r  r  r=  s     ra   	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s+      88AQ888888rc   )r  rU   )getrh   r1  rT   NotImplementedr$   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncri   zerosr   re   rX   appendrV   getattrnouttupler   	_na_value)rp   r2  r   inputsr   r5  r  r`   inputs2rZ   r=  s            @@ra   __array_ufunc__zBaseMaskedArray.__array_ufunc__  sW    jj### 	& 	&Aa!H4#6!H!H!HII &%%%%& <%
"(
 
 
,2
 
 ''MF??4eV&,  06   X7eV&,  06 F ^++xD		... 	" 	"A!_-- "qw''''q!!!!	 	 	 	 	 	8 ('';F;;:>>8888888888xz~~ &~%M;v&&&rc   c                N    ddl }|                    | j        | j        |          S )z6
        Convert myself into a pyarrow Array.
        r   N)rZ   r}   )pyarrowr3   rV   rX   )rp   r}   pas      ra   __arrow_array__zBaseMaskedArray.__arrow_array__  s,     	xx
$x???rc   c                N    t          | j                                                  S r]   )re   rX   r   r   s    ra   r   zBaseMaskedArray._hasna'  s     DJNN$$%%%rc   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)rX   rd   r  r  r   r   r!   )rp   rZ   others      ra   _propagate_maskzBaseMaskedArray._propagate_mask/  sz     <:??$$D
%%d{e$$ *Us4yy)@)@d5kk):$Drc   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%          |          }t          |t                    r!t          |j        t(                    rt*          S |dv r)t          |t          j                  rt/          |          }|                     ||          }|t2          j        u rt          j        | j                  }| j        j        dk    r6|dv rt          d	| d
          |dv rd}nd}|                    |          }nd|v r0| j        j        dk    r |                    t          j                  }n|dv r,|                     ||          }	|	|	                                 fS 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|t2          j        urt          j"        |dk    d|          }nw|dk    rq|t          j"        |dk    | z  d|          }n(|t2          j        urt          j"        |dk    d|          }t          j"        | j        dk    | j	         z  d|          }|                     ||          S )Nrk   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   r[  r\  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8re   r]  r{   >   divmodrdivmodrz   )r^  ra  r  )r|   r[  Fr   r\  )#__name__hasattrr   r   pd_arrayr5   rh   rT   rV   rX   r2   ri   r~   r   r   r&   maybe_prepare_scalar_for_opget_array_opr4   rk   r   rA  rl   re   rW  r  r  	ones_liker   r  float64r   rd   errstatewhere)
rp   rV  opop_nameomaskpd_oprZ   r`   rk   ress
             ra   _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e^,, 	"EK1T1T 	"!!o%%*UBH*E*E% KKE##E511JM!!\$*--Fz#%%    .OWOOO   o--"EE"Eu--g%%$*/S*@*@  rz22111--fd;;CHHJJ& 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   J77J;>J;r?   c                   ddl m} d }t          |t                    r!t          |j        t
                    rt          S 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	t2                     t-          j        dd	t4                     t7          | j        d
|j         d
          } ||          }|t          u rt;          | j        ||          }d d d            n# 1 swxY w Y   |                     ||          } |||d          S )Nr   r>   r   rZ  zLengths must match to comparere   rx   r  elementwise__Fr   )r9  r?   rh   r2   rk   r   rA  rT   rV   rX   r   ri   r~   r   r   r   ro   r  r  rE  rn   r   r  r  r  FutureWarningDeprecationWarningrG  rf  r8   rW  )rp   rV  ro  r?   rZ   r`   r   s          ra   _cmp_methodzBaseMaskedArray._cmp_method  s%   333333e^,, 	BEK1T1T 	B!!// 	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   1A?F<<G G r`   *np.ndarray | tuple[np.ndarray, np.ndarray]c                   t          |t                    r1|\  }}|                     ||          |                     ||          fS |j        j        dk    r9ddlm} t                      rd|t          j	        |          <    |||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 |j        t$          k    r| j        j        ||<   |S t          j        ||<   |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r{   r   rP   TFr   r   r>   r<  )TimedeltaArrayr'  rx   rz   r8  )rh   rI  r   rk   r   r9  rQ   r
   ri   r   r?   r   is_np_dtyper   r}  r}   rb   r8  r   r   r)  )	rp   r`   rZ   divra  rQ   r?   r}  r8  s	            ra   r   z"BaseMaskedArray._maybe_mask_result  s    fe$$ 	HC''T22''T22 
 <##888888{{ .)-RXf%%& =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\V##:.F4LM6F4LMrc   c                4    | j                                         S r]   )rX   rd   r   s    ra   r!   zBaseMaskedArray.isna  s    z   rc   c                    | j         j        S r]   r  r   s    ra   rJ  zBaseMaskedArray._na_value  s    z""rc   c                4    | j         j        | j        j        z   S r]   )rV   nbytesrX   r   s    ra   r  zBaseMaskedArray.nbytes  s    z 4:#444rc   	to_concatSequence[Self]c                    t          j        d |D             |          }t          j        d |D             |          } | ||          S )Nc                    g | ]	}|j         
S r   rV   r  s     ra   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>      :::1qw:::rc   r   c                    g | ]	}|j         
S r   )rX   r  s     ra   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>  r  rc   )ri   concatenate)r_   r  r   r   rZ   s        ra   _concat_same_typez!BaseMaskedArray._concat_same_type  sZ     ~::	:::FFF~::	:::FFFs4rc   encodinghash_key
categorizenpt.NDArray[np.uint64]c                   t          | j        |||          }t          | j        j                  ||                                 <   |S )N)r  r  r  )r9   rV   hashrk   r   r!   )rp   r  r  r  hashed_arrays        ra   _hash_pandas_objectz#BaseMaskedArray._hash_pandas_object  sJ     "JH
 
 
 %))<$=$=TYY[[!rc   )
allow_fillr   r   r  r   Scalar | Nonec               2   t          |          r| j        j        n|}t          | j        ||||          }t          | j        |d||          }|r1t          |          r"t          j        |          dk    }|||<   ||z  }| 	                    ||          S )N)r   r  r   Tr   )
r!   rk   r   r+   rV   rX   r"   ri   r~   rb   )	rp   indexerr  r   r   data_fill_valuer`   rZ   	fill_masks	            ra   r+   zBaseMaskedArray.take#  s     04J/?/?ODJ++Z 	 J&!
 
 
 JDZd
 
 
  	$%
++ 	$
7++r1I *F9)#D---rc   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   r>   c              3  4   K   | ]}|j         j        u V  d S r]   r  )r  r   rp   s     ra   r?  z'BaseMaskedArray.isin.<locals>.<genexpr>R  sF       @ @/2tz**@ @ @ @ @ @rc   rx   Fr   )r9  r?   ri   r~   r(   rV   r   rk   r   r   rX   rE  rn   re   )rp   rY   r?   
values_arrr`   values_have_NArZ   s   `      ra   r(   zBaseMaskedArray.isinI  s    333333 Z''
dj*--; 	0'-7 C @ @ @ @6@@ @ @ = =N "0F4:x
(555|FDu5555rc   c                    | j                                         }| j                                        }|                     ||          S r]   )rV   rd   rX   rb   )rp   r   rZ   s      ra   rd   zBaseMaskedArray.copy]  s:    z  z  d+++rc   averagekeep)r   r   	na_option	ascendingpctr  r  r  c          
        |dk    s| j         dk    rt          ddlm} | j        }|j        j        dk    r|                    d          }t          j	        |d||||| 
                                          }|dv r!t          j        | j        t          	          }	n| j                                        }	|d
k    r:|s8|dvr
d|| j        <   |                    dd          }ddlm}
  |
||	          S  |||	          S )Nr   r   rP   r   uint8F)is_datetimeliketies_methodr  r  r  rZ   topbottomrx   r  uint64r   r~  rZ   )r   r   r9  rQ   rV   rk   r   r  libalgosrank_1dr!   ri   rE  rn   re   rX   rd   r  r8  )rp   r   r   r  r  r  rQ   r   r`   rZ   r8  s              ra   _rankzBaseMaskedArray._rankb  s:    199	Q%%444444z:?c!!99W%%D!!
 
 
 )))8DJd333DD:??$$DYs 111%&tz"]]8%]88F777777<T2222}V$////rc   r   Literal['first', 'last', False]c                L    | j         }| j        }t          j        |||          S )a  
        Return boolean ndarray denoting duplicate values.

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

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

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

        Examples
        --------
        >>> pd.array([1, 1, 2, 3, 3], dtype="Int64").duplicated()
        array([False,  True, False, False,  True])
        )r  rZ   )rV   rX   r   
duplicated)rp   r  rY   rZ   s       ra   r  zBaseMaskedArray.duplicated  s*    > zT====rc   c                r    t          j        | j        | j                  \  }}|                     ||          S )z
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )r   unique_with_maskrV   rX   rb   )rp   uniquesrZ   s      ra   uniquezBaseMaskedArray.unique  s4     .tz4:FF...rc   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 )a8  
        Find indices where elements should be inserted to maintain order.

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

        Assuming that `self` is sorted:

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

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

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

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

        Examples
        --------
        >>> arr = pd.array([1, 2, 3, 5])
        >>> arr.searchsorted([4])
        array([3])
        zOsearchsorted requires array to be sorted, which is impossible with NAs present.)r  r  )r   ro   rh   r2   r  r   rV   searchsorted)rp   r   r  r  s       ra   r  zBaseMaskedArray.searchsorted  sh    d ; 	$   e^,, 	)LL((Ez&&u4&GGGrc   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 )al  
        Encode the extension array as an enumerated type.

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

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

            .. note::

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

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

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

        Examples
        --------
        >>> idx1 = pd.PeriodIndex(
        ...     ["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"],
        ...     freq="M",
        ... )
        >>> arr, idx = idx1.factorize()
        >>> arr
        array([0, 0, 1, 1, 2, 2])
        >>> idx
        PeriodIndex(['2014-01', '2014-02', '2014-03'], dtype='period[M]')
        T)r  rZ   r   rx   r   Nr   )rV   rX   r'   rk   r   r   r   ri   rE  re   r   intpmaxinsertrb   )rp   r  arrrZ   codesr  has_nasizeuniques_maskna_indexna_code
uniques_eas               ra   	factorizezBaseMaskedArray.factorize  sf   ` 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  rc   c                    | j         S )a  
        Return values for sorting.

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

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

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

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

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

        >>> arr = pd.array([1, 2, 3])
        >>> arr._values_for_argsort()
        array([1, 2, 3])
        r  r   s    ra   _values_for_argsortz#BaseMaskedArray._values_for_argsortG  s    @ zrc   dropnar=   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
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   )Indexr=   r~  r  rZ   rx   Tr   Fr   count)indexnamerd   )pandasr  r=   pandas.arraysr8  r   value_counts_arraylikerV   rX   ri   rE  r   rl   rd   rk   r(  )rp   r  r  r=   r8  keysvalue_counts
na_counter
mask_indexrZ   r  r  s               ra   r  zBaseMaskedArray.value_countsi  s   "	
 	
 	
 	
 	
 	
 	
 	
 	/.....).)EJvDJ*
 *
 *
&lJ Xs<002"(CCC
  >>!JrNl<..-DJ++--  
 
 
 vcW5AAAArc   c                    t          | j        || j                  \  }} t          |           ||          }||                                         S )Nr  )r*   rV   rX   r}   argsort)rp   r  r`   res_masks       ra   _modezBaseMaskedArray._mode  sK    
6
KKKdFH--fnn&&''rc   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 )a  
        Return if another array is equivalent to this array.

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

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

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

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

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

        >>> arr1 = pd.array([1, 3, np.nan])
        >>> arr2 = pd.array([1, 2, np.nan])
        >>> arr1.equals(arr2)
        False
        FT)
strict_nandtype_equal)r}   rk   ri   array_equalrX   rV   r   )rp   rV  r  rights       ra   equalszBaseMaskedArray.equals  s    H ::e$$5;$*$$5 ~dj%+66 	5z4:+&U[L)e$OOOOrc   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.
        )rZ   r   r  r     rx   r  )r.   rV   rX   ri   r)  r   r   r   r!   r|   r   rn   re   r   rk   rE  r   r   )rp   r  r  rs  out_masks        ra   	_quantilezBaseMaskedArray._quantile  s     !J v'
 
 
 ; 	7 yA~~ *)yy{{   ;739D999#DJ// L (39DJ4JKKKC8CIT:::x	666H&&s&:::rc   )skipnakeepdimsr  r  r  c               .   |dv r t          | |          dd|i|}nI| j        }| j        }t          t          d|           }|                    dd           }	 ||f|	||d|}|rt          |          r|                     |dd          S t                      rt          j	        |g          }n|
                    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  rZ   r   )r   )r  r   	mask_sizer   rx   r   )rG  rV   rX   r%   popr!   _wrap_na_resultr   ri   r3   r   rE  re   r   r  r  )
rp   r  r  r  r   r`   r   rZ   ro  r   s
             ra   _reducezBaseMaskedArray._reduce  s6    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')) /Xvh//FF#^^A..Fx.....vt<<<<< 	= Mrc   c                   t          |t          j                  rO|r| j                            |          }n| j                            |          }|                     ||          S |S r   )rh   ri   rj   rX   r|   r   r   )rp   r  r`   r  r   rZ   s         ra   _wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result  se    fbj)) 	9 1z~~4~00z~~4~00**64888rc   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 )Nrx   Float32r;  rl  )r  medianr  r  skewkurtsem)r  r     int32int64uint32r  )r   r   ur{   r   r  )ri   r   re   rk   itemsizer   r  r   r   r   r3   r   )rp   r  r   r  rZ   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              ra   r  zBaseMaskedArray._wrap_na_result  s    wy---"&*	"9"9YYy
JJJ!HH^##tz':a'?'?z-2HH"5"7"7"Ct8"5Bww7H$7EXI%H9:VV
H !H---&&u4&888rc   c                   |dk    rNt          |t          j                  r4|                     |t          j        |j        t                              S |                     ||||          S )Nr   rx   r  r   )rh   ri   rj   r   rE  rn   re   r   )rp   r  r`   r  	min_countr   s         ra    _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_result1  sb     >>j<<>**628FLPT3U3U3UVVV**4T*RRRrc   r  r  r   r  AxisInt | Nonec                   t          j        d|           t          j        | j        | j        |||          }|                     d||||          S )Nr   r  r  )r   validate_sumr-   r  rV   rX   r  rp   r  r  r   r   r`   s         ra   r  zBaseMaskedArray.sum8  sj     	F###"&JJ
 
 
 446&ID 5 
 
 	
rc   c                   t          j        d|           t          j        | j        | j        |||          }|                     d||||          S )Nr   r  r  )r   validate_prodr-   r  rV   rX   r  r  s         ra   r  zBaseMaskedArray.prodM  sk     	V$$$"'JJ
 
 
 44F6YT 5 
 
 	
rc   r  c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_meanr-   r  rV   rX   r   rp   r  r   r   r`   s        ra   r  zBaseMaskedArray.meanb  s[    
V$$$"'JJ	
 
 
 **66&t*TTTrc   r  r   ddofr!  c                   t          j        d|d           t          j        | j        | j        |||          }|                     d|||          S )Nr   r  fnamer   r  )r   validate_stat_ddof_funcr-   r  rV   rX   r   rp   r  r   r!  r   r`   s         ra   r  zBaseMaskedArray.varl  e     	"2vU;;;;"&JJ
 
 
 **5&d*SSSrc   c                   t          j        d|d           t          j        | j        | j        |||          }|                     d|||          S )Nr   r  r#  r   r  )r   r%  r-   r  rV   rX   r   r&  s         ra   r  zBaseMaskedArray.stdy  r'  rc   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_minr-   r  rV   rX   r   r  s        ra   r  zBaseMaskedArray.min  Z    
F###"&JJ	
 
 
 **5&d*SSSrc   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_maxr-   r  rV   rX   r   r  s        ra   r  zBaseMaskedArray.max  r+  rc   	na_actionLiteral['ignore'] | Nonec                J    t          |                                 ||          S )N)r.  )r)   r  )rp   mapperr.  s      ra   mapzBaseMaskedArray.map  s    &IFFFFrc   Literal[True]np.bool_c                   d S r]   r   rp   r  r   r   s       ra   r   zBaseMaskedArray.any  	     3rc   r   np.bool_ | NATypec                   d S r]   r   r6  s       ra   r   zBaseMaskedArray.any  	      Crc   c               P   t          j        d|           | j                                        }t	          j        || j        | j        j                   |	                                }|r|S |s,t          |           dk    s| j        	                                s|S | j        j        S )aV  
        Return whether any element is truthy.

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

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

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

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

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

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

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

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        np.True_
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        np.True_
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        r   r   )r   validate_anyrV   rd   ri   putmaskrX   rk   _falsey_valuer   r   r   rp   r  r   r   rY   r`   s         ra   r   zBaseMaskedArray.any  s    ~ 	F###""

64:tz'?@@@ 	'M 	's4yyA~~TZ^^-=-=~M:&&rc   c                   d S r]   r   r6  s       ra   r|   zBaseMaskedArray.all  r7  rc   c                   d S r]   r   r6  s       ra   r|   zBaseMaskedArray.all  r:  rc   c               T   t          j        d|           | j                                        }t	          j        || j        | j        j                   |	                    |          }|r|S |r,t          |           dk    s| j                                        s|S | j        j        S )aI  
        Return whether all elements are truthy.

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

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

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

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

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

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

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

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        np.False_
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        np.False_
        r   r   r   )r   validate_allrV   rd   ri   r=  rX   rk   _truthy_valuer|   r   r   r   r?  s         ra   r|   zBaseMaskedArray.all  s    ~ 	F###""

64:tz'?@@@&& 	'M 	'3t99>>1A1A>M:&&rc   rG   rQ   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{   rz   Tf8z)interpolate is not implemented for dtype=r   )r   r   r  r   limit_directionr   rZ   rP   )rk   r   rV   rd   rX   r  r   r   interpolate_2d_inplacer}   rb   r9  rQ   )rp   r   r   r  r   rG  r   rd   r   r   rZ   rQ   s               ra   interpolatezBaseMaskedArray.interpolateH  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8rc   )r  c                   | j         }| j        }t          t          |          } |||fd|i|\  }}|                     ||          S )Nr  )rV   rX   rG  r,   rb   )rp   r  r  r   r   rZ   ro  s          ra   _accumulatezBaseMaskedArray._accumulate|  sZ     zz)400Rd<<6<V<<
dd+++rc   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)rL  r   rM  	aggregaterx   rankr  r  F)r  rN  comp_idsrZ   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsrR  get_kind_from_howrX   r   rd   ri   rE  re   r@  _cython_op_ndim_compatrV   rL  _cython_aritytiler   r   )rp   rL  rM  r  rN  rO  r   rR  r   ro  rZ   rV  
res_valuesaritys                 ra   _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Crc   )rY   rU   rZ   rW   r[   r   )F)rY   rU   rZ   rW   rd   re   r[   rf   )rd   re   r[   r   )r[   rB   )rn   rM   rk   r   r[   r   )r   re   r[   r   )r[   r   )r   rK   r[   r   )r   rL   r[   r   )r   rI   r[   r   )
r   rF   r   r   r   r   rd   re   r[   r   rU  )r   r   rd   re   r[   r   )rk   rE   rd   re   r[   r   )r[   rf   )r[   re   )r[   r;   )r[   r   )r[   rM   )r[   r   )r   )r   rD   r[   r   )r   N)r   r   r[   r   )r   r   )r[   rU   )rk   r  rd   re   r   r   r[   rU   )r[   r  ).)rk   r   rd   re   r[   rU   )rk   r   rd   re   r[   r2   )rk   rC   rd   re   r[   rB   )T)NN)rk   r-  rd   r.  r[   rU   )r2  r3  r   r   r]   )rZ   rS  r[   rW   )r[   r?   )r`   r{  rZ   rU   )r  r  r   rD   r[   r   )r  r   r  r   r  re   r[   r  )r  re   r   r  r   rD   r[   r   )rY   rB   r[   r?   )
r   rD   r   r   r  r   r  re   r  re   )r   )r  r  r[   rW   )r  N)r   r  r  r  r  r  r[   r  )r  re   r[   r  )r  re   r[   r=   )r  re   r[   r   )r  r  r  r   r[   rT   )r  r   r  re   r  re   )r  r   )r  re   r  r   r   r  )r  re   r   r  )r  re   r   r  r!  r   )r.  r/  )r  r3  r   r  r[   r4  )r  re   r   r  r[   r8  )r   rG   r   r   rd   re   r[   rQ   )r  r   r  re   r[   rT   )
rL  r   rM  re   r  r   rN  r   rO  rP  )Yrf  
__module____qualname____doc____annotations__classmethodrb   rq   rv   r   r   r   propertyrk   r	   r   r   r   rt   r   r   r   r   r   rn   r   r   r   r   r   r/   r   r   r   r   r   r  r  r   r+  r  r  r  __array_priority__r0  rM  rQ  r   rW  rt  _logical_methodrz  r   r!   rJ  r  r  r  r+   r(   rd   r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  r  r2  r   r|   rI  rK  ra  __classcell__)r   s   @ra   rT   rT   z   s<
                 [ MR    & .2 ! ! ! ! ! [!       [(     ( ( ( X( ::: X:=== X=   & !:>) ) ) ) ) )V; ; ; ; ;z 6;' ' ' ' ' ['
O O O4   ,/ / / / / /              X     X, , , ,
, , , , ,
, , , ,
& & & &	. 	. 	. 	. 	. < < < X<B B B B BF@ @ @ @@ @ @ @   D D D D
. . . .
 '+>	^ ^ ^ ^ ^@K K K K: OOOO XOTTTT XTJJJJ XJ, , , , ,\  AE5 5 5 5 50 %$$$M' M' M' M'^@ @ @ @ & & & X&   c5 c5 c5J $O*6 *6 *6 *6X3 3 3 3j! ! ! ! # # X# 5 5 5 X5      [    !$(". ". ". ". ". ".L6 6 6 6(, , , , )0 )0 )0 )0 )0 )0X 7>!> !> !> !> !>F	/ 	/ 	/ 	/ *0%)	:H :H :H :H :H| !%N! N! N! N! N!`       D(B (B (B (B (BT( ( ( ( (
0P 0P 0P 0Pd'; '; '; ';Z ,0%     :	 	 	 	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 G ),S     X 69          X 
 !%QI' I' I' I' I' I'V ),S     X 69          X 
 !%QJ' J' J' J' J' J'X29 29 29 29j ,0	, 	, 	, 	, 	, 	,-D -D -D -D -D -D -D -Drc   rT   masked_arraysSequence[BaseMaskedArray]r[   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   )rV   r   r  r  s     ra   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>  s*    @@@3ci2&&@@@rc   F)orderrk   )r   r5  c                D    g | ]}|j                             d d          S rp  )rX   r   rq  s     ra   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>  s*    ???#SYq"%%???rc   rx   r   Nr  )r  rk   ri   r  r   r   r   
empty_likere   r(  r   rn   rF  )
rk  rk   rY   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs
             ra   #transpose_homogeneous_masked_arraysr|    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rc   )rk  rl  r[   rm  )u
__future__r   typingr   r   r   r   r   r	   r  numpyri   pandas._configr
   r   pandas._libsr   r  r   r   r  pandas._libs.tslibsr   pandas.compatr   r   pandas.errorsr   pandas.core.dtypes.astyper   pandas.core.dtypes.baser   pandas.core.dtypes.castr   pandas.core.dtypes.commonr   r   r   r   r   r   pandas.core.dtypes.dtypesr   r   pandas.core.dtypes.missingr   r    r!   r"   pandas.corer#   r$   r%   r&   pandas.core.algorithmsr'   r(   r)   r*   r+   pandas.core.array_algosr,   r-    pandas.core.array_algos.quantiler.   "pandas.core.array_algos.transformsr/   pandas.core.arrayliker0   pandas.core.arrays._utilsr1   pandas.core.arrays.baser2   pandas.core.constructionr3   rh  r4   r5   pandas.core.indexersr6   r7   pandas.core.opsr8   pandas.core.util.hashingr9   collections.abcr:   r;   r<   r  r=   r9  r?   pandas._typingr@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   pandas._libs.missingrO   rQ   pandas.compat.numpyrR   r   rT   r|  r   rc   ra   <module>r     sT   " " " " " "                           
         
 3 2 2 2 2 2        . - - - - - 4 4 4 4 4 4 2 2 2 2 2 2                                                                        @ ? ? ? ? ? 4 4 4 4 4 4 * * * * * * > > > > > > 2 2 2 2 2 2         
        / . . . . . / / / / / / 1((((((        //////                                 " ,+++++000000 . . . . . .}D }D }D }D }Dh }D }D }D@:! ! ! ! ! !rc   