
     	i                    T   d dl mZ d dlmZmZmZmZmZ d dlZd dl	Z
d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m!Z!m"Z" d dl#m$Z$ d d	l%m&Z& d d
l'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8m9Z9m:Z: d dl;m<Z=m>Z>mZm?Z?m@Z@ d dlAmBZBmCZCmDZDmEZEmFZF d dlGmHZHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZQ d dlRmSZTmUZUmVZV d dlWmXZX d dlYmZZZ d dl[m\Z\ er"d dl]m^Z^m_Z_ d dl`maZa d dlbmcZc d dlmdZdmeZe d dlbmfZf d d lgmhZi  G d! d"eMeQ          Zjd(d'Zkd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)find_stack_level)validate_fillna_kwargs)ExtensionDtype)is_boolis_integer_dtypeis_list_like	is_scalaris_string_dtypepandas_dtype)BaseMaskedDtype)array_equivalentis_valid_na_for_dtypeisnanotna)
algorithms	arrayliker
   nanopsops)factorize_arrayisin	map_arraymodetake)masked_accumulationsmasked_reductions)quantile_with_mask)OpsMixin)to_numpy_dtype_inference)ExtensionArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexer)invalid_comparison)
hash_array)IteratorSequence)SeriesBooleanArray)NumpySorterNumpyValueArrayLikeFloatingArray)functionc                      e Zd ZU dZded<   ded<   ded<   eZeZe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da<   ddeZ0ddfZ1eddg            Z2ddiZ3dj Z4e4Z5ddlZ6ddoZ7ddpZ8edq             Z9eddr            Z:e	 dddu            Z;ddzZ<ddd@d{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)rM   __new__rP   rR   )clsrS   rT   results       Q/srv/django_bis/venv311/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^   rP   rR   )selfrS   rT   r^   s       r[   __init__zBaseMaskedArray.__init__   s     4,, 	rx1G1G2   <4:%%ABBB 	[[]]F99;;D



r]   Nre   r^   c               P    |                      |||          \  }} | ||          S )Nrl   )_coerce_to_array)rY   scalarsre   r^   rS   rT   s         r[   _from_sequencezBaseMaskedArray._from_sequence   s2    ++G5t+LLs64   r]   rh   r   re   r!   c                   t          j        ||j                  }|                    | j                   t          j        |t                    } | ||          }t          ||           r||j        k    rt          d| d          |S )Nre   z5Default 'empty' implementation is invalid for dtype='')
rc   emptytypefillrN   onesr_   rb   re   NotImplementedError)rY   rh   re   rS   rT   rZ   s         r[   _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 rW   )str)rj   rz   s     r[   
_formatterzBaseMaskedArray._formatter   s    
r]   r(   c                     t          |           rW   r   rj   s    r[   re   zBaseMaskedArray.dtype   s    !$'''r]   itemr   r   c                    d S rW    rj   r   s     r[   __getitem__zBaseMaskedArray.__getitem__       r]   r   c                    d S rW   r   r   s     r[   r   zBaseMaskedArray.__getitem__   r   r]   r   
Self | Anyc                    t          | |          }| j        |         }t          |          r|r| j        j        S | j        |         S |                     | j        |         |          S rW   )r?   rR   r"   re   na_valuerP   r\   )rj   r   newmasks      r[   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   rT      insideoutside)rR   anyr
   get_fill_funcr   rP   Tr^   allargmaxlenr\   )rj   r   r   r   r^   rT   funcnpvaluesnew_maskneg_maskfirstlast
new_valuess                r[   _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    rR   r
   check_value_sizer   r   r   r   rP   r   r^   r\   )
rj   valuer   r   r^   rT   r   r   r   r   s
             r[   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          |           rW   r   )rY   rS   re   r^   s       r[   rn   z BaseMaskedArray._coerce_to_array  s     "#&&&r]   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
        bfzInvalid value 'z' for dtype 'rs   )re   kindr	   r"   
is_integeris_floatrg   )rj   r   r   s      r[   _validate_setitem_valuez'BaseMaskedArray._validate_setitem_value  s     z3;;{5!!  S[[~e$$ U(;(;  ~e$$ e)<)< AQAQASAS 
 M%MM
MMMNNNr]   c                @   t          | |          }t          |          rKt          || j                  rd| j        |<   n)|                     |          }|| j        |<   d| j        |<   d S |                     || j                  \  }}|| j        |<   || j        |<   d S )NTFrr   )r?   r%   r*   re   rR   r   rP   rn   )rj   keyr   rT   s       r[   __setitem__zBaseMaskedArray.__setitem__4  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+   re   r   rP   r   r	   r   r_   rc   isnanrR   r   super__contains__)rj   r   	__class__s     r[   r   zBaseMaskedArray.__contains__E  s    99 	HDJ$777z$++S0A0A+RXdj11TZK?DDFFGGGEGG((--...r]   rB   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   _hasnarP   re   r   ziprR   ranger   )rj   valr   isna_is        r[   __iter__zBaseMaskedArray.__iter__M  s      9>>; 	":  CIIII   :."%dj$*"="= " "JE3 "&!					" " 3t99%%  1g r]   intc                *    t          | j                  S rW   )r   rP   r   s    r[   __len__zBaseMaskedArray.__len__]  s    4:r]   c                    | j         j        S rW   )rP   rh   r   s    r[   rh   zBaseMaskedArray.shape`  s    zr]   c                    | j         j        S rW   )rP   r   r   s    r[   r   zBaseMaskedArray.ndimd  s    zr]   c                    | j                             ||          }| j                            ||          }|                     ||          S rW   )rP   swapaxesrR   r\   )rj   axis1axis2datarT   s        r[   r   zBaseMaskedArray.swapaxesh  sF    z""5%00z""5%00d+++r]   r   axisr   c                    t          j        | j        ||          }t          j        | j        ||          }|                     ||          S Nr   )rc   deleterP   rR   r\   )rj   locr   r   rT   s        r[   r   zBaseMaskedArray.deletem  sH    ySt444ySt444d+++r]   c                v     | j         j        |i |} | j        j        |i |}|                     ||          S rW   )rP   reshaperR   r\   rj   argskwargsr   rT   s        r[   r   zBaseMaskedArray.reshaper  sJ    !tz!42622!tz!42622d+++r]   c                |     | j         j        |i |} | j        j        |i |} t          |           ||          S rW   )rP   ravelrR   ru   r   s        r[   r   zBaseMaskedArray.ravelw  sL    tz000tz000tDzz$%%%r]   c                V    |                      | j        j        | j        j                  S rW   )r\   rP   r   rR   r   s    r[   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   )
re   r   nvvalidate_roundrc   roundrP   _maybe_mask_resultrR   r^   )rj   r   r   r   rS   s        r[   r   zBaseMaskedArray.round  sm    0 :?c!!K
$'''$*BBxB6BB &&vtz/@/@AAAr]   c                h    |                      | j         | j                                                  S rW   r\   rP   rR   r^   r   s    r[   
__invert__zBaseMaskedArray.__invert__  (    TZ__->->???r]   c                h    |                      | j         | j                                                  S rW   r   r   s    r[   __neg__zBaseMaskedArray.__neg__  r   r]   c                *    |                                  S rW   r   r   s    r[   __pos__zBaseMaskedArray.__pos__  s    yy{{r]   c                    |                      t          | j                  | j                                                  S rW   )r\   absrP   rR   r^   r   s    r[   __abs__zBaseMaskedArray.__abs__  s,    DJ1B1BCCCr]   c                8    t          j        | t                    S )Nrr   )rc   asarrayobjectr   s    r[   _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   r:   r   r&   
libmissingNAri   warningscatch_warningsfilterwarningsRuntimeWarningrP   astyperR   )rj   re   r^   r   hasnar   s         r[   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     r[   
<listcomp>z*BaseMaskedArray.tolist.<locals>.<listcomp>  s     ---1AHHJJ---r]   re   r   )r   r   rP   re   r   r   r   r  )rj   re   s     r[   r  zBaseMaskedArray.tolist  sZ    9q==------9)9}}5:=}AAHHJJJr]   .npt.DTypeLikec                    d S rW   r   rj   re   r^   s      r[   r   zBaseMaskedArray.astype  r   r]   r;   c                    d S rW   r   r
  s      r[   r   zBaseMaskedArray.astype  r   r]   r   r   c                    d S rW   r   r
  s      r[   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   Frl   r   MNaTiuzcannot convert NA to integerr   z cannot convert float NaN to bool)re   r   r^   )r'   re   r^   rb   r(   r   r   r   r   rP   r   numpy_dtyperR   construct_array_typer!   rp   r   rc   nan
datetime64r	   
no_defaultr   ri   r   )rj   re   r^   r   rT   rY   eaclsr   s           r[   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 rK| j         st          j        | j        ||          S t	          j        dt          t                                 |d}|                     ||          S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        Frl   aS  Starting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0.
This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead.)
stacklevel)	r   rc   r<   rP   r   warnFutureWarningr   r   r
  s      r[   	__array__zBaseMaskedArray.__array__U  s     5==; Dx
%dCCCCM2 +--	 	 	 	 <D}}5t}444r]   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   reducerr   r  rO   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   )rF   rJ   IntegerArrayr   r  r   )pandas.core.arraysrF   rJ   r%  re   r   r^   rc   float16r   float32r  )r  rF   rJ   r%  mrT   s        r[   reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct  s              w|s""IIKK#|Aq)))%%IIKK#|Aq)))$$IIKK7bj(( ,,A$}Q***&$Hr]   r   c              3  .   K   | ]} |          V  d S rW   r   )r  r  r*  s     r[   	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>  s+      88AQ888888r]   )r  rO   )getrb   r  rM   NotImplementedr.   !maybe_dispatch_ufunc_to_dunder_opdispatch_ufunc_with_outdispatch_reduction_ufuncrc   zerosr   r_   rR   appendrP   getattrnouttupler   	_na_value)rj   r  r   inputsr   r"  r  rZ   inputs2rT   r*  s            @@r[   __array_ufunc__zBaseMaskedArray.__array_ufunc__r  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)rT   ru   )pyarrowr<   rP   rR   )rj   ru   pas      r[   __arrow_array__zBaseMaskedArray.__arrow_array__  s,     	xx
$x???r]   c                4    | j                                         S rW   )rR   r   r   s    r[   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)rR   r^   r   r   r$   r   r+   )rj   rT   others      r[   _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 )Nre   T)extract_numpyr   (can only perform ops with 1-d structures>   powrpowr   >   rG  rH  truedivfloordivrtruediv	rfloordivz
operator 'z!' not implemented for bool dtypes>   modrmodint8r_   rI  r   r  )rJ  rM  r   )r   rG  Fr   rH  ) __name__hasattrr$   r   pd_arrayr>   rb   rM   rP   rR   r;   rc   r   r   rx   r0   maybe_prepare_scalar_for_opget_array_opr=   rf   r_   rC  r   r   	ones_likere   r   r   float64errstatewherer   )	rj   rB  opop_nameomaskpd_oprT   rZ   re   s	            r[   _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rF   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   rE   r   rF  zLengths must match to comparer_   rr   r   elementwise__Fr   )r&  rF   rb   rM   rP   rR   r$   rc   r   r   rx   r   ri   r   r   r2  rh   rw   r   r   r   r  DeprecationWarningr4  rP  r.  r@   rC  )rj   rB  rY  rF   rT   rZ   r   s          r[   _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
rZ   *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   rI   Fr   r   rE   r)  )TimedeltaArrayr  rr   r  r%  )rb   r6  r   re   r   r&  rJ   rF   r	   is_np_dtyper   re  ru   r\   r%  rc   r  )	rj   rZ   rT   divrM  rJ   rF   re  r%  s	            r[   r   z"BaseMaskedArray._maybe_mask_resultg  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 rW   )rR   r^   r   s    r[   r+   zBaseMaskedArray.isna  s    z   r]   c                    | j         j        S rW   r  r   s    r[   r7  zBaseMaskedArray._na_value  s    z""r]   c                4    | j         j        | j        j        z   S rW   )rP   nbytesrR   r   s    r[   rl  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   rP   r  s     r[   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>      :::1qw:::r]   r   c                    g | ]	}|j         
S r   )rR   r  s     r[   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>  rr  r]   )rc   concatenate)rY   rm  r   r   rT   s        r[   _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)rv  rw  rx  )rA   rP   hashre   r   r+   )rj   rv  rw  rx  hashed_arrays        r[   _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+   rN   r5   rP   rR   r,   rc   r   r\   )	rj   indexerr~  r  r   data_fill_valuerZ   rT   	fill_masks	            r[   r5   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   rE   c              3  4   K   | ]}|j         j        u V  d S rW   r  )r  r   rj   s     r[   r,  z'BaseMaskedArray.isin.<locals>.<genexpr>  sF       @ @/2tz**@ @ @ @ @ @r]   rr   Fr   )r&  rF   rc   r   r2   rP   r   re   r   r   rR   r2  rh   r_   )rj   rS   rF   
values_arrrZ   values_have_NArT   s   `      r[   r2   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 rW   )rP   r^   rR   r\   )rj   r   rT   s      r[   r^   zBaseMaskedArray.copy  s:    z  z  d+++r]   r   keepLiteral['first', 'last', False]c                L    | j         }| j        }t          j        |||          S )N)r  rT   )rP   rR   algos
duplicated)rj   r  rS   rT   s       r[   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_maskrP   rR   r\   )rj   uniquesrT   s      r[   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   ri   rb   r;   r   r   rP   searchsorted)rj   r   r  r  s       r[   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  rT   r   rr   r   r   )rP   rR   r1   re   r  r   r   rc   r2  r_   r   intpmaxinsertr\   )rj   r  arrrT   codesr  has_nasizeuniques_maskna_indexna_code
uniques_eas               r[   	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 rW   rq  r   s    r[   _values_for_argsortz#BaseMaskedArray._values_for_argsort:  s
    zr]   dropnarD   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   )IndexrD   rf  r  rT   rr   Tr   countF)indexnamer^   )pandasr  rD   pandas.arraysr%  r  value_counts_arraylikerP   rR   rc   r2  r   rf   r^   re   r  )rj   r  r  rD   r%  keysvalue_counts
na_counter
mask_indexrT   r  r  s               r[   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  rr   )	r4   rP   rR   rc   r2  rh   rf   ru   argsort)rj   r  rZ   res_masks       r[   _modezBaseMaskedArray._modef  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)ru   re   rc   array_equalrR   rP   r)   )rj   rB  r  rights       r[   equalszBaseMaskedArray.equalso  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.
        )rT   r  r  r     rr   rT   )r8   rP   rR   rc   r  r   r   rx   r+   r   rw   rh   r_   r#   re   r2  r  r   )rj   r  r  resout_masks        r[   	_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&:::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  rT   r   )r   )r  r   	mask_sizer   rr   r   )r4  rP   rR   r/   popr+   _wrap_na_resultr   rc   r2  r_   r   r   r   )
rj   r  r  r  r   rZ   r   rT   rY  r   s
             r[   _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   )rb   rc   rd   rR   r   r   r   )rj   r  rZ   r  r   rT   s         r[   _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 )Nrr   Float32r(  rV  )r  medianr  r  skewkurt)r  r     int32int64uint32uint64)r   r   ur   r   r  )rc   rw   r_   re   itemsizer  r  r   r   r   r<   r   )rj   r  r   r  rT   
float_dtypnp_dtypeis_windows_or_32bitint_dtyp	uint_dtypr   s              r[   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   rr   r  r   )rb   rc   rd   r   r2  rh   r_   r  )rj   r  rZ   r  	min_countr   s         r[    _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_sumr7   r  rP   rR   r  rj   r  r  r   r   rZ   s         r[   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_prodr7   r  rP   rR   r  r  s         r[   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_meanr7   r  rP   rR   r  rj   r  r   r   rZ   s        r[   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_funcr7   r  rP   rR   r  rj   r  r   r  r   rZ   s         r[   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  r7   r  rP   rR   r  r  s         r[   r  zBaseMaskedArray.std+  r  r]   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_minr7   r  rP   rR   r  r  s        r[   r  zBaseMaskedArray.min8  Z    
F###"&JJ	
 
 
 **5&d*SSSr]   c                   t          j        d|           t          j        | j        | j        ||          }|                     d|||          S )Nr   r  r  )r   validate_maxr7   r  rP   rR   r  r  s        r[   r  zBaseMaskedArray.maxB  r  r]   c                J    t          |                                 ||          S )N)	na_action)r3   r   )rj   mapperr  s      r[   mapzBaseMaskedArray.mapL  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_anyrP   r^   rc   putmaskrR   _falsey_valuer   r   re   r   rj   r  r   r   rS   rZ   s         r[   r   zBaseMaskedArray.anyO  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_allrP   r^   rc   r  rR   _truthy_valuer   r   r   re   r   r  s         r[   r   zBaseMaskedArray.all  s    ~ 	F###"" 	
64:t'9:::&& 	+M +SYY!^^4:>>3C3C^z**r]   r   rJ   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   rT   rI   )re   r   rP   r^   rR   r   rx   r
   interpolate_2d_inplaceru   r\   r&  rJ   )rj   r   r   r  r   r  r   r^   r   r   rT   rJ   s               r[   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  )rP   rR   r4  r6   r\   )rj   r  r  r   r   rT   rY  s          r[   _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  	aggregaterr   rank	na_option)topbottomF)r  r  comp_idsrT   result_maskohlcr   )idxminidxmax)pandas.core.groupby.opsr#  get_kind_from_howrR   r   r^   rc   r2  r_   r-  _cython_op_ndim_compatrP   r  _cython_aritytiler   r   )rj   r  r  r  r  r   r   r#  r   rY  rT   r*  
res_valuesaritys                 r[   _groupby_opzBaseMaskedArray._groupby_op4  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]   )rS   rO   rT   rQ   rU   r   )F)rS   rO   rT   rQ   r^   r_   rU   r`   )r^   r_   rU   r   )rh   r   re   r!   )rz   r_   rU   r{   )rU   r(   )r   r   rU   r   )r   r   rU   r   )r   r   rU   r   )
r   r   r   r   r   r   r^   r_   rU   r   )NNNT)r   r   r^   r_   rU   r   )re   r   r^   r_   rU   r   )rU   r`   )rU   r_   )rU   rB   )rU   r   )rU   r   )rU   r   )r   )r   r   rU   r   )r   r   )rU   rO   )re   r   r^   r_   r   r   rU   rO   ).)re   r  r^   r_   rU   rO   )re   r!   r^   r_   rU   r;   )re   r   r^   r_   rU   r   )T)NN)re   r  r^   r  rU   rO   )r  r   r   r}   rW   )rT   r@  rU   rQ   )rU   rF   )rZ   rc  rT   rO   )rm  rn  r   r   rU   r   )rv  r}   rw  r}   rx  r_   rU   ry  )r~  r_   r  r  r   r   rU   r   )rS   r   rU   rF   )r   )r  r  rU   rQ   )r  N)r   r  r  r  r  r  rU   r  )r  r_   rU   r  )r  r_   rU   rD   )r  r_   rU   r   )r  r  r  r}   rU   rM   )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_   rU   rJ   )r  r}   r  r_   rU   rM   )
r  r}   r  r_   r  r   r  r   r   r!  )[rP  
__module____qualname____doc____annotations__r   r  r  classmethodr\   rk   rp   r   r;   ry   r~   propertyre   r   r   r   r   rn   r   r   r   r   r   rh   r   r   r   r   r   r   r   r   r   r   r   r   r	   r  r   r  r   __array_priority__r  r:  r>  r   rC  r]  _logical_methodrb  r   r+   r7  rl  ru  r}  r5   r2   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  r5  __classcell__)r   s   @r[   rM   rM   l   s-
          !        MM   [ MR    & .2 ! ! ! ! ! [! S		 	 	   [	     ( ( ( X(    X    X
; 
; 
; 
;  !:>* * * * * *X 	S	NR     B 6;' ' ' ' ' ['
O O O6   "/ / / / / /              X     X, , , ,
, , , , ,
, , , ,
& & & & < < < X<B B B B BF@ @ @ @@ @ @ @   D D D D
. . . .
 '+>	[ [ [ [ [z 	S	K K  K     X     X     X, , , , ,\  AE5 5 5 5 56 %$$$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]   rM   masked_arraysSequence[BaseMaskedArray]rU   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   )rP   r   r  r  s     r[   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>o  s*    @@@3ci2&&@@@r]   F)orderre   )r   r"  c                D    g | ]}|j                             d d          S rD  )rR   r   rE  s     r[   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>z  s*    ???#SYq"%%???r]   rr   r   Nr  )listre   rc   rt  rt   r   r  
empty_liker_   r  r   rh   r3  )
r?  re   rS   transposed_valuesmaskstransposed_masksarr_typetransposed_arraysr   transposed_arrs
             r[   #transpose_homogeneous_masked_arraysrQ  d  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@  rU   rA  )l
__future__r   typingr   r   r   r   r   r   numpyrc   pandas._libsr	   r
   r   pandas._libs.tslibsr   pandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas.compatr   r   pandas.errorsr   pandas.util._decoratorsr   pandas.util._exceptionsr   pandas.util._validatorsr    pandas.core.dtypes.baser!   pandas.core.dtypes.commonr"   r#   r$   r%   r&   r'   pandas.core.dtypes.dtypesr(   pandas.core.dtypes.missingr)   r*   r+   r,   pandas.corer-   r  r.   r/   r0   pandas.core.algorithmsr1   r2   r3   r4   r5   pandas.core.array_algosr6   r7    pandas.core.array_algos.quantiler8   pandas.core.arrayliker9   pandas.core.arrays._utilsr:   pandas.core.arrays.baser;   pandas.core.constructionr<   rR  r=   r>   pandas.core.indexersr?   pandas.core.opsr@   pandas.core.util.hashingrA   collections.abcrB   rC   r  rD   r&  rF   rG   rH   rJ   pandas.compat.numpyrK   r   rM   rQ  r   r]   r[   <module>rn     s   " " " " " "                          3 2 2 2 2 2                                        . - - - - - ' ' ' ' ' ' 4 4 4 4 4 4 : : : : : : 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 . . . . . .uD uD uD uD uDh uD uD uDp/! ! ! ! ! !r]   