Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/site-packages/pandas/core/arrays/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/site-packages/pandas/core/arrays/__pycache__/masked.cpython-312.pyc

�

MٜgR���H�ddlmZddlmZmZmZmZmZddlZddl	Z
ddlmZm
ZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddl m!Z!m"Z"ddl#m$Z$dd	l%m&Z&dd
l'm(Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1dd
l2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8ddl9m:Z;m<Z<m
Z
m=Z=m>Z>ddl?m@Z@mAZAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOddlPmQZRmSZSmTZTddlUmVZVddlWmXZXddlYmZZZer"ddl[m\Z\m]Z]ddl^m_Z_ddl`maZaddlmbZbmcZcddl`mdZdddlemfZgGd �d!eKeO�Zh				d#d"�Ziy)$�)�annotations)�
TYPE_CHECKING�Any�Callable�Literal�overloadN)�lib�missing)�is_supported_dtype)�	ArrayLike�	AstypeArg�AxisInt�DtypeObj�
FillnaOptions�InterpolateOptions�NpDtype�PositionalIndexer�Scalar�
ScalarIndexer�Self�SequenceIndexer�Shape�npt)�IS64�is_platform_windows��AbstractMethodError)�doc)�validate_fillna_kwargs)�ExtensionDtype)�is_bool�is_integer_dtype�is_list_like�	is_scalar�is_string_dtype�pandas_dtype)�BaseMaskedDtype)�array_equivalent�is_valid_na_for_dtype�isna�notna)�
algorithms�	arrayliker
�nanops�ops)�factorize_array�isin�	map_array�mode�take)�masked_accumulations�masked_reductions)�quantile_with_mask)�OpsMixin)�to_numpy_dtype_inference)�ExtensionArray)�array�ensure_wrapped_if_datetimelike�
extract_array)�check_array_indexer)�invalid_comparison)�
hash_array)�Iterator�Sequence)�Series��BooleanArray)�NumpySorter�NumpyValueArrayLike��
FloatingArray)�functionc���eZdZUdZded<ded<ded<eZeZedgd��Z		dh							did
�Z
edd	d�djd
��Zeee
j�dkd���Zdhdld�Zedmd��Zednd��Zedod��Zdpd�Zdddd�									dqd�Zee
j*�	dr					dsd��Zed	d�					dtd��Zd�Zdud�Zdv�fd�Zdwd�Zdxd�Zedyd��Zedxd ��Zdzd!�Zd{d|d#�Zdzd$�Z dzd%�Z!edzd&��Z"d{d}d'�Z#dzd(�Z$dzd)�Z%dzd*�Z&dzd+�Z'd~d,�Z(dd	e)jTf							dd-�Z+ee
jX�d.��Z,ed�d�d/��Z-ed�d�d0��Z-ed�d�d1��Z-d�d�d2�Z-d3Z.	d�					d�d4�Z/d5ed6<d�d7�Z0d�d8�Z1edvd9��Z2				d�d:�Z3d;�Z4e4Z5d�d<�Z6				d�d=�Z7d~d>�Z8ed?��Z9edxd@��Z:e	d{					d�dA��Z;								d�dB�Z<d	dd"dC�							d�dD�Z=d�dE�Z>dzdF�Z?ee
j��	d�			d�dG��Z@dzdH�ZAee
j��		d�							d�dI��ZBee
j��	d�			d�dJ��ZCee
j��d~dK��ZDd�d�dL�ZEd�d�dM�ZFee
j��dvdN��ZG						d�dO�ZHdd	dP�					d�dQ�ZId�dR�ZJdS�ZK		d�dT�ZLdd"d"dU�					d�dV�ZMdd"d"dU�					d�dW�ZNdd"dX�d�dY�ZOdd"dZd[�					d�d\�ZPdd"dZd[�					d�d]�ZQdd"dX�d�d^�ZRdd"dX�d�d_�ZSd�d`�ZTdd"dX�d�da�ZUdd"dX�d�db�ZV								d�dc�ZWddd�					d�de�ZX										d�df�ZY�xZZS)��BaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r�_internal_fill_value�
np.ndarray�_data�npt.NDArray[np.bool_]�_maskc�L�tj|�}||_||_|S�N)rL�__new__rOrQ)�cls�values�mask�results    �D/usr/local/lib/python3.12/site-packages/pandas/core/arrays/masked.py�_simple_newzBaseMaskedArray._simple_new|s%�� �(�(��-���������
�Fc�0�t|tj�r|jtjk(std��|j|jk7rtd��|r |j�}|j�}||_	||_
y)NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)�
isinstance�np�ndarray�dtype�bool_�	TypeError�shape�
ValueError�copyrOrQ)�selfrVrWres    rY�__init__zBaseMaskedArray.__init__�sx���4����,����r�x�x�1G��2��
��<�<�4�:�:�%��A�B�B���[�[�]�F��9�9�;�D���
���
r[N�r`rec�B�|j|||��\}}|||�S)Nrh)�_coerce_to_array)rU�scalarsr`rerVrWs      rY�_from_sequencezBaseMaskedArray._from_sequence�s*���+�+�G�5�t�+�L�����6�4� � r[c��tj||j��}|j|j�tj
|t��}|||�}t||�r||jk7rtd|�d���|S)N�r`z5Default 'empty' implementation is invalid for dtype='�')
r^�empty�type�fillrM�ones�boolr]r`�NotImplementedError)rUrcr`rVrWrXs      rY�_emptyzBaseMaskedArray._empty�s{�����%�u�z�z�2�����C�,�,�-��w�w�u�D�)���V�T�"���&�#�&�%�6�<�<�*?�%�G��w�a�P��
��
r[c��tSrS)�str)rf�boxeds  rY�
_formatterzBaseMaskedArray._formatter�s���
r[c��t|��rSr�rfs rYr`zBaseMaskedArray.dtype�s
��!�$�'�'r[c��yrS��rf�items  rY�__getitem__zBaseMaskedArray.__getitem__����r[c��yrSr~rs  rYr�zBaseMaskedArray.__getitem__�r�r[c���t||�}|j|}t|�r'|r|jjS|j
|S|j
|j
||�SrS)r>rQr!r`�na_valuerOrZ)rfr��newmasks   rYr�zBaseMaskedArray.__getitem__�sb��"�4��.���*�*�T�"���7����z�z�*�*�*��:�:�d�#�#�����
�
�4� 0�'�:�:r[T)�limit�
limit_arearec��|j}|j��rMtj||j��}|j
j}|j}|r!|j�}|j�}n|�|j�}||||��|��|j�s�|j}|}	|	j�}
t|	�|	ddd�j�z
dz
}|dk(r)|d|
xxx|d|
zccc||dzdxxx||dzdzcccn|dk(r||
dz|xxx||
dz|zccc|r&|j|j|j�S|S|r|j�}|S|}|S)N��ndim�r�rW�����inside�outside)rQ�anyr
�
get_fill_funcr�rO�Tre�all�argmax�lenrZ)
rf�methodr�r�rerW�func�npvalues�new_mask�neg_mask�first�last�
new_valuess
             rY�_pad_or_backfillz BaseMaskedArray._pad_or_backfill�sv���z�z���8�8�:��(�(��d�i�i�@�D��z�z�|�|�H��v�v�H��#�=�=�?��#�=�=�?���'��y�y�{�����X�6��%�d�h�h�j��v�v�� �5�� ���)���8�}�x��"��~�'<�'<�'>�>��B����)��V�e�$��V�e��4�$��T�A�X�Z�(�D�����,<�<�(��9�,��U�Q�Y��.�$�u�q�y�4�2H�H�.���'�'��
�
�H�J�J�?�?����!�Y�Y�[�
���"�
��r[c�<�t||�\}}|j}tj||t	|��}|j�r�|��tj||j��}|jj}|j}|r |j�}|j�}||||��|j|j|j�S|r|j�}	n|dd}	||	|<|	S|r|j�}	|	S|dd}	|	S)Nr�r�)rrQr
�check_value_sizer�r�r�r�rOr�rerZ)
rf�valuer�r�rerWr�r�r�r�s
          rY�fillnazBaseMaskedArray.fillna�s��/�u�f�=�
��v��z�z���(�(���c�$�i�@���8�8�:��!��,�,�V�$�)�)�D���:�:�<�<���6�6���'�}�}��H�'�}�}��H��X�U��:��'�'��
�
�H�J�J�?�?��!%����J�!%�a��J�#(�
�4� ���	�!�Y�Y�[�
���"�!�W�
��r[�rec��t|��rSr)rUrVr`res    rYrjz BaseMaskedArray._coerce_to_arrays��"�#�&�&r[c��|jj}|dk(rtj|�ro|S|dk(r,tj|�stj
|�r>|Stj|�s%tj
|�r|j	�r|St
dt|��d|j����)zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        �b�fzInvalid value 'z' for dtype )r`�kindr	r!�
is_integer�is_floatrbrx)rfr�r�s   rY�_validate_setitem_valuez'BaseMaskedArray._validate_setitem_values����z�z�����3�;��{�{�5�!���
�S�[��~�~�e�$����U�(;����~�~�e�$����e�)<��AQ�AQ�AS���
�/�#�e�*��\�$�*�*��N�O�Or[c�Z�t||�}t|�rVt||j�rd|j|<y|j|�}||j|<d|j|<y|j||j��\}}||j|<||j|<y)NTFrn)r>r$r)r`rQr�rOrj)rf�keyr�rWs    rY�__setitem__zBaseMaskedArray.__setitem__3s���!�$��,���U��$�U�D�J�J�7�"&��
�
�3��

��4�4�U�;��"'��
�
�3��"'��
�
�3����+�+�E����+�D���t���
�
�3����
�
�3�r[c�r��t|�r�||jjur||jjjdk(rYtj|�rDttj|j�|jzj��Stt�|�5|��S)Nr�)r*r`r�rOr�r	r�rtr^�isnanrQr��super�__contains__)rfr��	__class__s  �rYr�zBaseMaskedArray.__contains__Ds�����9��D�J�J�$7�$7�7��z�z���$�$��+����S�0A��R�X�X�d�j�j�1�T�Z�Z�K�?�D�D�F�G�G��E�G�(��-�.�.r[c#�BK�|jdk(rl|js|jD]}|���y|jj}t|j|j�D]\}}|r|���
|���ytt|��D]	}||���y�w)Nr�)	r��_hasnarOr`r��ziprQ�ranger�)rf�valr��isna_�is     rY�__iter__zBaseMaskedArray.__iter__Ls������9�9��>��;�;��:�:�C��I�&� �:�:�.�.��"%�d�j�j�$�*�*�"=�J�E�3��&��!�	�	#>��3�t�9�%���1�g�
�&�s�BBc�,�t|j�SrS)r�rOr|s rY�__len__zBaseMaskedArray.__len__\s���4�:�:��r[c�.�|jjSrS)rOrcr|s rYrczBaseMaskedArray.shape_s���z�z���r[c�.�|jjSrS)rOr�r|s rYr�zBaseMaskedArray.ndimcs���z�z���r[c��|jj||�}|jj||�}|j||�SrS)rO�swapaxesrQrZ)rf�axis1�axis2�datarWs     rYr�zBaseMaskedArray.swapaxesgsA���z�z�"�"�5�%�0���z�z�"�"�5�%�0������d�+�+r[rc��tj|j||��}tj|j||��}|j	||�S�N��axis)r^�deleterOrQrZ)rf�locr�r�rWs     rYr�zBaseMaskedArray.deletelsA���y�y����S�t�4���y�y����S�t�4������d�+�+r[c��|jj|i|��}|jj|i|��}|j||�SrS)rO�reshaperQrZ�rf�args�kwargsr�rWs     rYr�zBaseMaskedArray.reshapeqsK��!�t�z�z�!�!�4�2�6�2��!�t�z�z�!�!�4�2�6�2������d�+�+r[c��|jj|i|��}|jj|i|��}t|�||�SrS)rO�ravelrQrqr�s     rYr�zBaseMaskedArray.ravelvsK���t�z�z����0��0���t�z�z����0��0���t�D�z�$��%�%r[c�v�|j|jj|jj�SrS)rZrOr�rQr|s rYr�zBaseMaskedArray.T|s%������
�
���d�j�j�l�l�;�;r[c��|jjdk(r|Stj||�t	j
|jfd|i|��}|j||jj��S)a�
        Round each value in the array a to the given number of decimals.

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

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

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r��decimals)
r`r��nv�validate_roundr^�roundrO�_maybe_mask_resultrQre)rfr�r�r�rVs     rYr�zBaseMaskedArray.round�se��0�:�:�?�?�c�!��K�
���$��'����$�*�*�B�x�B�6�B���&�&�v�t�z�z���/@�A�Ar[c�l�|j|j|jj��SrS�rZrOrQrer|s rY�
__invert__zBaseMaskedArray.__invert__��&���������T�Z�Z�_�_�->�?�?r[c�l�|j|j|jj��SrSr�r|s rY�__neg__zBaseMaskedArray.__neg__�r�r[c�"�|j�SrSr�r|s rY�__pos__zBaseMaskedArray.__pos__�s���y�y�{�r[c�|�|jt|j�|jj	��SrS)rZ�absrOrQrer|s rY�__abs__zBaseMaskedArray.__abs__�s(������D�J�J�������1B�C�Cr[c�8�tj|t��S)Nrn)r^�asarray�objectr|s rY�_values_for_jsonz BaseMaskedArray._values_for_json�s���z�z�$�f�-�-r[c�b�|j}t||||�\}}|�t}|r�|tk7r,t|�s!|tj
urt
d|�d���tj�5tjdt��|jj|�}ddd�||j<|Stj�5tjdt��|jj||��}ddd�|S#1swY�qxYw#1swYSxYw)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])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.�ignore��categoryr�)r�r9r�r%�
libmissing�NArd�warnings�catch_warnings�filterwarnings�RuntimeWarningrO�astyperQ)rfr`rer��hasnar�s      rY�to_numpyzBaseMaskedArray.to_numpy�s��D����2�4���%�P���x��=��E�����'��.��
�
�
�-� �)�%��1&�&����(�(�*��'�'��>�J��z�z�(�(��/��+� (�D�����
���(�(�*��'�'��>�J��z�z�(�(��T�(�:��+���+�*��
+���s�17D�9D$�D!�$D.c��|jdkDr|D�cgc]}|j���c}S|jrdn|jj}|j|tj��j�Scc}w)Nr��r`r�)r��tolistr�rOr`r�r�r�)rf�xr`s   rYr�zBaseMaskedArray.tolistsd���9�9�q�=�(,�-��1�A�H�H�J��-�-��������)9�)9���}�}�5�:�=�=�}�A�H�H�J�J��.s�Bc��yrSr~�rfr`res   rYr�zBaseMaskedArray.astyper�r[c��yrSr~r�s   rYr�zBaseMaskedArray.astyper�r[c��yrSr~r�s   rYr�zBaseMaskedArray.astype r�r[c���t|�}||jk(r|r|j�S|St|t�r�tj�5tjdt��|jj|j|��}ddd�|jur|jn|jj�}|j�}|||d��St|t�r$|j�}|j|||��S|j dk(rt"j$}n5|j dk(rt#j&d�}nt(j*}|j d	vr|j,rt/d
��|j dk(r|j,rt/d��|j1|||�
�}|S#1swY��CxYw)Nr�r�r�Frhr��M�NaT�iuzcannot convert NA to integerr�z cannot convert float NaN to bool)r`r�re)r&r`rer]r'r�r�r�r�rOr��numpy_dtyperQ�construct_array_typer rlr�r^�nan�
datetime64r	�
no_defaultr�rdr�)rfr`rer�rWrU�eaclsr�s        rYr�zBaseMaskedArray.astype$s����U�#���D�J�J����y�y�{�"��K��e�_�-��(�(�*��'�'��>�J��z�z�(�(��):�):��(�F��+�"&����!3�4�:�:������9J�D��,�,�.�C��t�T��.�.��e�^�,��.�.�0�E��'�'��E��'�E�E�
�:�:����v�v�H�
�Z�Z�3�
��}�}�U�+�H��~�~�H��:�:���$�+�+��;�<�<��:�:�������?�@�@��}�}�5�8�$�}�G����C+�*�s
�AG�G!i�c�&�|j|��S)z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rn)r�r�s   rY�	__array__zBaseMaskedArray.__array__Ts���}�}�5�}�)�)r[ztuple[type, ...]�_HANDLED_TYPESc�8�	�
�|jdd�}||zD](}t||jtfz�r�"tcStj|||g|��i|��}|tur|Sd|vrtj|||g|��i|��S|dk(r%tj|||g|��i|��}|tur|Stjt|�t���	g}|D]N}t|t�r+�	|jz�	|j|j��>|j|��Pd�	fd��
t!||�|i|��}|j"dkDrt%�
fd�|D��S|dk(r(|jj'�r|j(S|S�
|�S)	N�outr~�reducernc����ddlm}m}m}|jj
dk(r�j
�}|||�S|jj
dvr�j
�}|||�S|jj
dk(rU�j
�}|jtjk(r|jtj�}|||�Stj|�<|S)Nr)rErI�IntegerArrayr�rr�)�pandas.core.arraysrErIrr`r�rer^�float16r��float32r)r�rErIr�mrWs     �rY�reconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct�s����
�
��w�w�|�|�s�"��I�I�K��#�A�q�)�)�������%��I�I�K��#�A�q�)�)�������$��I�I�K���7�7�b�j�j�(�������,�A�$�Q��*�*��&�&��$���Hr[r�c3�.�K�|]}�|����y�wrSr~)�.0r�rs  �rY�	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>�s�����8��A��Q���s�)r�rN)�getr]r
rL�NotImplementedr-�!maybe_dispatch_ufunc_to_dunder_op�dispatch_ufunc_with_out�dispatch_reduction_ufuncr^�zerosr�rtrQ�appendrO�getattr�nout�tupler��	_na_value)rf�ufuncr��inputsr�rr�rX�inputs2rWrs         @@rY�__array_ufunc__zBaseMaskedArray.__array_ufunc___s�����j�j���#���#��A��a��!4�!4��7I�!I�J�%�%��
�<�<��%��
�"(�
�,2�
����'��M��F�?��4�4��e�V��&,��06��
��X���7�7��e�V��&,��06��F��^�+��
��x�x��D�	��.�����A��!�_�-����������q�w�w�'����q�!��	�4(����'��;�F�;���:�:��>��8��8�8�8�
�x�
��z�z�~�~���~�~�%��M��v�&�&r[c�Z�ddl}|j|j|j|��S)z6
        Convert myself into a pyarrow Array.
        rN)rWrq)�pyarrowr;rOrQ)rfrq�pas   rY�__arrow_array__zBaseMaskedArray.__arrow_array__�s$��	��x�x��
�
����$�x�?�?r[c�6�|jj�SrS)rQr�r|s rYr�zBaseMaskedArray._hasna�s���z�z�~�~��r[c���|�e|jj�}|tjur|dz}|St	|�r%t|�t|�k(r|t
|�z}|S|j|z}|S)NT)rQrer�r�r#r�r*)rfrW�others   rY�_propagate_maskzBaseMaskedArray._propagate_mask�sz���<��:�:�?�?�$�D��
�
�
�%��d�{����
�e�$��U��s�4�y�)@��d�5�k�)��
���:�:��$�D��r[c���|j}d}t|d�s:t|�r/t|�t|�k(rt	|�}t|d��}t
|t�r|j|j}}nJt|�r?t
|t�stj|�}|jdkDrtd��tj |t|�f�}tj"|�}t%|�}|dvr%t
|tj&�rt)|�}|j+||�}|t,j.ur�tj0|j�}|j2j4dk(r.|dvrtd	|�d
���|dvrd}nd
}|j7|�}n�d|vr�|j2j4dk7rp|j7tj8�}nP|j2j4dvr|dvr|}tj:d��5||j|�}ddd�|dk(r�tj<|jdk(|jzd|�}|�tj<|dk(|zd|�}n�|t,j.ur�tj<|dk(d|�}n�|dk(r|�tj<|dk(|zd|�}n,|t,j.urtj<|dk(d|�}tj<|jdk(|jzd|�}|j?|�S#1swY��%xYw)Nr`T)�
extract_numpyr��(can only perform ops with 1-d structures>�pow�rpowr�>r2r3�truediv�floordiv�rtruediv�	rfloordivz
operator 'z!' not implemented for bool dtypes>�mod�rmod�int8rtr4r�r)r5r8r�)r�r2Frr3) �__name__�hasattrr#r��pd_arrayr=r]rLrOrQr:r^r�r�rur/�maybe_prepare_scalar_for_op�get_array_opr<rartr.r�r��	ones_liker`r�r��float64�errstate�wherer�)	rfr-�op�op_name�omask�pd_oprWrXr`s	         rY�
_arith_methodzBaseMaskedArray._arith_method�s����+�+������w�'��U�#��E�
�c�$�i�'��U�O�E�!�%�t�<�E��e�_�-� �;�;����5�E�
�%�
 ��e�^�4��
�
�5�)���z�z�A�~�)�*T�U�U��/�/���D�	�|�D��� � ��$��.�u�5���o�%�*�U�B�H�H�*E���K�E��#�#�E�5�1���J�M�M�!��\�\�$�*�*�-�F��z�z���#�%����.�$�W�I�-N�O����o�-�"�E�"�E����u�-���g�%�$�*�*�/�/�S�*@� ���r�z�z�2���z�z���$�&�7�6I�+I�������*��t�z�z�5�1��+��e���8�8�T�Z�Z�1�_�����;�U�D�I�D�� ��x�x��!���v� 5�u�d�C���j�m�m�+��x�x���
�E�4�8��
��
�� ��x�x��!���v� 5�u�d�C���j�m�m�+��x�x���
�E�4�8���8�8�T�Z�Z�1�_�����;�U�D�I�D��&�&�v�t�4�4�++�*�s�,M#�#M-c�|�ddlm}d}t|t�r|j|j
}}n\t
|�rQtj|�}|jdkDrtd��t|�t|�k7rtd��|tjurWtj|jj d��}tj"|jj d��}n�t%j&�5t%j(dd	t*�t%j(dd	t,�t/|jd
|j0�d
��}||�}|t2urt5|j||�}ddd�|j7||�}||d��S#1swY�&xYw)
NrrDr�r1zLengths must match to comparertrnr��elementwise�__Fr�)rrEr]rLrOrQr#r^r�r�rur�rdr�r�rrcrsr�r�r��
FutureWarning�DeprecationWarningrr;rr?r.)rfr-rDrErWrXr�s       rY�_cmp_methodzBaseMaskedArray._cmp_method,sT��3����e�_�-��+�+�u�{�{�4�E�
�%�
 ��J�J�u�%�E��z�z�A�~�)�*T�U�U��4�y�C��J�&� �!@�A�A��J�M�M�!�
�X�X�d�j�j�.�.�f�=�F��7�7�4�:�:�+�+�6�:�D��(�(�*��'�'��-��O��'�'��-�AS�T� ����r�"�+�+��b�-A�B�������^�+�/��
�
�E�2�F�F�+��#�#�D�%�0���F�D�u�5�5�+�*�s
�BF2�2F;c��t|t�r)|\}}|j||�|j||�fS|jjdk(rddlm}|||d��S|jjdk(rddlm}|||d��Stj|jd�rdt|j�rOdd	lm}|jjd
�||<t||�s|j||j��S|S|jjdvrdd
lm}|||d��Stj ||<|S)z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r�rrHFr�r�rDr)�TimedeltaArrayrrnr�r)r]r!r�r`r�rrIrEr	�is_np_dtyperrPrqrZrr^r)	rfrXrW�divr8rIrErPrs	         rYr�z"BaseMaskedArray._maybe_mask_resultTs%���f�e�$��H�C���'�'��T�2��'�'��T�2��
�
�<�<����#�8� ���E�:�:�
�\�\�
�
�#�
%�7����5�9�9�
�_�_�V�\�\�3�
/�4F�v�|�|�4T�9�!�<�<�,�,�U�3�F�4�L��f�n�5�%�1�1�&����1�M�M��M�
�\�\�
�
�$�
&�7����5�9�9��6�6�F�4�L��Mr[c�6�|jj�SrS)rQrer|s rYr*zBaseMaskedArray.isna�s���z�z��� � r[c�.�|jjSrSr�r|s rYr"zBaseMaskedArray._na_value�s���z�z�"�"�"r[c�\�|jj|jjzSrS)rO�nbytesrQr|s rYrWzBaseMaskedArray.nbytes�s!���z�z� � �4�:�:�#4�#4�4�4r[c���tj|D�cgc]}|j��c}|��}tj|D�cgc]}|j��c}|��}|||�Scc}wcc}wr�)r^�concatenaterOrQ)rU�	to_concatr�r�r�rWs      rY�_concat_same_typez!BaseMaskedArray._concat_same_type�s^���~�~�	�:�	�1�q�w�w�	�:��F���~�~�	�:�	�1�q�w�w�	�:��F���4�����;��:s�A(�A-c��t|j|||��}t|jj�||j�<|S)N)�encoding�hash_key�
categorize)r@rO�hashr`r�r*)rfr]r^r_�hashed_arrays     rY�_hash_pandas_objectz#BaseMaskedArray._hash_pandas_object�sB��"��J�J��H��
��%)����)<�)<�$=��T�Y�Y�[�!��r[)�
allow_fill�
fill_valuer�c��t|�r|jn|}t|j||||��}t|j|d||��}|r-t|�r"t
j|�dk(}|||<||z}|j||�S)N)rdrcr�Tr�)	r*rMr4rOrQr+r^r�rZ)	rf�indexerrcrdr��data_fill_valuerXrW�	fill_masks	         rYr4zBaseMaskedArray.take�s���8<�J�7G�$�3�3�Z����J�J��&�!��
����J�J��D�Z�d�
���%�
�+��
�
�7�+�r�1�I� *�F�9���)�#�D������-�-r[c�b��ddlm}tj|�}t	�j
|�}�jr8|jtk(xrt�fd�|D��}||�j<tj�j
jt��}|||d��S)NrrDc3�N�K�|]}|�jju���y�wrSr�)rr�rfs  �rYrz'BaseMaskedArray.isin.<locals>.<genexpr>�s%�����@�6@�s��t�z�z�*�*�*�j�s�"%rnFr�)rrEr^r�r1rOr�r`r�r�rQrrcrt)rfrVrE�
values_arrrX�values_have_NArWs`      rYr1zBaseMaskedArray.isin�s����3��Z�Z��'�
��d�j�j�*�-���;�;�'�-�-��7��C�@�6@�@�=�N�"0�F�4�:�:���x�x��
�
�(�(��5���F�D�u�5�5r[c��|jj�}|jj�}|j||�SrS)rOrerQrZ)rfr�rWs   rYrezBaseMaskedArray.copy�s5���z�z��� ���z�z��� ������d�+�+r[c�b�|j}|j}tj|||��S)N)�keeprW)rOrQ�algos�
duplicated)rfrorVrWs    rYrqzBaseMaskedArray.duplicated�s+�������z�z������T��=�=r[c��tj|j|j�\}}|j	||�S)z�
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rp�unique_with_maskrOrQrZ)rf�uniquesrWs   rY�uniquezBaseMaskedArray.unique�s5���.�.�t�z�z�4�:�:�F�
��������.�.r[c��|jrtd��t|t�r|j	t
�}|jj|||��S)NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)�side�sorter)r�rdr]r:r�r�rO�searchsorted)rfr�rwrxs    rYryzBaseMaskedArray.searchsorted�sS���;�;��$��
��e�^�,��L�L��(�E��z�z�&�&�u�4��&�G�Gr[c��|j}|j}t|d|��\}}|j|jjk(sJ|j|jf��|j�}|s|st
|�}nt
|�dz}tj|t��}|sw|ru|j�}	|	dk(rtjd�}
n|d|	j�dz}
|||
k\xxdz
cc<|
||dk(<tj||
d�}d||
<|j||�}||fS)NT)�use_na_sentinelrWr�rnrr�)rOrQr0r`rr�r�r^rrtr��intp�max�insertrZ)rfr{�arrrW�codesrt�has_na�size�uniques_mask�na_index�na_code�
uniques_eas            rY�	factorizezBaseMaskedArray.factorizes-��
�j�j���z�z��)��d��N���w��}�}��
�
� 6� 6�6�S�����
�
�8S�S�6�������&��w�<�D��w�<�!�#�D��x�x��D�1���6��{�{�}�H��1�}��'�'�!�*���	��*�.�.�0�1�4���%�7�"�#�q�(�#�!(�E�%�2�+���i�i���!�4�G�$(�L��!��%�%�g�|�<�
��j� � r[c��|jSrS)rOr|s rY�_values_for_argsortz#BaseMaskedArray._values_for_argsort's���z�z�r[c��ddlm}m}ddlm}tj|j||j��\}}}tjt|�ftj��}|j�}	|dkDrd|d<|||	�}
||jj�||��}||
|dd	�
�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)�IndexrCrQ��dropnarWrnTr��countF)�index�namere)�pandasr�rC�
pandas.arraysrrp�value_counts_arraylikerOrQr^rr�rarer`r)rfr�r�rCr�keys�value_counts�
na_counter�
mask_indexrWrr�s            rYr�zBaseMaskedArray.value_counts+s���"	
�	/�).�)E�)E��J�J�v�D�J�J�*
�&��l�J��X�X�s�<�0�2�"�(�(�C�
���� ����>�!�J�r�N��<��.���-�D�J�J�+�+�-��j�
�
��
�c��W�5�A�Ar[c�>�|rRt|j||j��}tj|j
tj��}n%t|j||j��\}}t|�||�}||j�S)Nr�rn)	r3rOrQr^rrcrarq�argsort)rfr�rX�res_masks    rY�_modezBaseMaskedArray._modeSsr����$�*�*�V�$�*�*�E�F��x�x����B�H�H�=�H�#�D�J�J�v�D�J�J�O��F�H���d��F�H�-���f�n�n�&�'�'r[c�B�t|�t|�k7ry|j|jk7rytj|j|j�sy|j
|j}|j
|j}t
||dd��S)NFT)�
strict_nan�dtype_equal)rqr`r^�array_equalrQrOr()rfr-�left�rights    rY�equalszBaseMaskedArray.equals\s|����:��e��$���;�;�$�*�*�$���~�~�d�j�j�%�+�+�6���z�z�4�:�:�+�&�����U�[�[�L�)����e��$�O�Or[c��t|j|jtj||��}|j
r�|jdk(rt�|j�j�rptj|jt��}t|j�r�tj|j|jj ��}nKtj|jt��}n%tj|jt��}|j#||��S)z�
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rWrd�qs�
interpolation�rn�rW)r7rOrQr^rr�r�rur*r�rsrcrtr"r`rrr�)rfr�r��res�out_masks     rY�	_quantilezBaseMaskedArray._quantilels���!��J�J�����v�v��'�
���;�;��y�y�A�~�*�)��y�y�{��� ��7�7�3�9�9�D�9��#�D�J�J�/��(�(�3�9�9�D�J�J�4J�4J�K�C��8�8�C�I�I�T�:���x�x��	�	��6�H��&�&�s��&�:�:r[)�skipna�keepdimsc��|dvrt||�dd|i|��}nJ|j}|j}ttd|���}|j	dd�}	||f|	||d�|��}|r]t|�r|j
|dd��S|jd	�}tjd	t�
�}|j||�St|�rtjS|S)N>	r�r�r}�min�std�sum�var�mean�prodr�rr�)r�r�rWr)r�)r�r��	mask_sizer�rnr~)rrOrQr.�popr*�_wrap_na_resultr�r^rrtr�r�r�)
rfr�r�r�r�rXr�rWrDr�s
          rY�_reducezBaseMaskedArray._reduce�s����T�T�(�W�T�4�(�A��A�&�A�F��:�:�D��:�:�D���3�t�f��.�B��:�:�f�d�+�D���L�4��T�L�V�L�F���F�|��+�+��A��+�N�N�����*���x�x���.���.�.�v�t�<�<���<��=�=� ��Mr[c���t|tj�rM|r|jj	|��}n|jj|��}|j
||�S|Sr�)r]r^r_rQr�r�r�)rfr�rXr�r�rWs      rY�_wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result�sS���f�b�j�j�)���z�z�~�~�4�~�0���z�z�~�~�4�~�0���*�*�6�4�8�8��
r[c��tj|t��}|jdk(rdnd}|dvr|}n{|dvs|jjdk(r!|jj
j}n=t�xst}|rdnd	}|rd
nd}	|||	|d�|jj}tjd
g|��}
|j|
|��S)Nrn�Float32rrA)r��medianr�r��skew�kurt)r�r}��int32�int64�uint32�uint64)r�r��ur�r�r�)r^rsrtr`�itemsizerr�rrr�r;r�)rfr�r�r�rW�
float_dtyp�np_dtype�is_windows_or_32bit�int_dtyp�	uint_dtypr�s           rYr�zBaseMaskedArray._wrap_na_result�s����w�w�y��-��"&�*�*�	�"9�Y�y�
��C�C�!�H�
�^�
#�t�z�z�':�':�a�'?��z�z�-�-�2�2�H�"5�"7�"C�t�8��"5�w�7�H�$7��X�I�%�H�9�:�V��
�
����H����!��H�-���&�&�u�4�&�8�8r[c���|dk(rOt|tj�r5|j|tj|j
t���S|j||||��S)Nrrn�r�r�)r]r^r_r�rrcrtr�)rfr�rXr��	min_countr�s      rY� _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_result�sU����>�j�����<��*�*�6�2�8�8�F�L�L�PT�3U�V�V��*�*�4���T�*�R�Rr[�r�r�r�c��tjd|�tj|j|j
|||��}|j
d||||��S)Nr~r�r�)r��validate_sumr6r�rOrQr��rfr�r�r�r�rXs      rYr�zBaseMaskedArray.sum�s^��	����F�#�"�&�&��J�J��J�J����
���4�4��6�&�I�D�5�
�	
r[c��tjd|�tj|j|j
|||��}|j
d||||��S)Nr~r�r�)r��
validate_prodr6r�rOrQr�r�s      rYr�zBaseMaskedArray.prod�s`��	����V�$�"�'�'��J�J��J�J����
���4�4��F�6�Y�T�5�
�	
r[r�c��tjd|�tj|j|j
||��}|j
d|||��S)Nr~r�r�)r��
validate_meanr6r�rOrQr��rfr�r�r�rXs     rYr�zBaseMaskedArray.meansR��
����V�$�"�'�'��J�J��J�J���	
���*�*�6�6�&�t�*�T�Tr[r��r�r��ddofc��tjd|d��tj|j|j
|||��}|j
d|||��S)Nr~r���fnamer�r�)r��validate_stat_ddof_funcr6r�rOrQr��rfr�r�r�r�rXs      rYr�zBaseMaskedArray.var�Y��	�"�"�2�v�U�;�"�&�&��J�J��J�J����
���*�*�5�&��d�*�S�Sr[c��tjd|d��tj|j|j
|||��}|j
d|||��S)Nr~r�r�r�r�)r�r�r6r�rOrQr�r�s      rYr�zBaseMaskedArray.stdr�r[c��tjd|�tj|j|j
||��}|j
d|||��S)Nr~r�r�)r��validate_minr6r�rOrQr�r�s     rYr�zBaseMaskedArray.min%�P��
����F�#�"�&�&��J�J��J�J���	
���*�*�5�&��d�*�S�Sr[c��tjd|�tj|j|j
||��}|j
d|||��S)Nr~r�r})r��validate_maxr6r}rOrQr�r�s     rYr}zBaseMaskedArray.max/r�r[c�:�t|j�||��S)N)�	na_action)r2r�)rf�mapperr�s   rY�mapzBaseMaskedArray.map9s�������&�I�F�Fr[c�d�tjd|�|jj�}t	j
||j|j�|j�}|r|S|s(t|�dk(s|jj�s|S|jjS)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_anyrOrer^�putmaskrQ�
_falsey_valuer�r�r`r��rfr�r�r�rVrXs      rYr�zBaseMaskedArray.any<s���~	����F�#������"��	�
�
�6�4�:�:�t�'9�'9�:��������M���T��a��t�z�z�~�~�/?��
��z�z�*�*�*r[c�h�tjd|�|jj�}t	j
||j|j�|j|��}|r|S|r(t|�dk(s|jj�s|S|jjS)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_allrOrer^r�rQ�
_truthy_valuer�r�r�r`r�r�s      rYr�zBaseMaskedArray.all�s���~	����F�#������"��	�
�
�6�4�:�:�t�'9�'9�:������&����M��S��Y�!�^�4�:�:�>�>�3C��
��z�z�*�*�*r[c��|jjdk(rP|r5|jj�}	|jj�}
n�|j}	|j}
nh|jjdvr8d}|jjd�}	|jj�}
nt
d|j����tj|	f|d|||||
d�|��|s|S|jjdk(rt|�j|	|
�Sddlm}|j|	|
�S)	z2
        See NDFrame.interpolate.__doc__.
        r�rT�f8z)interpolate is not implemented for dtype=r)r�r�r�r��limit_directionr�rWrH)
r`r�rOrerQr�rur
�interpolate_2d_inplacerqrZrrI)rfr�r�r�r�r�r�rer�r�rWrIs            rY�interpolatezBaseMaskedArray.interpolate�s�� �:�:�?�?�c�!���z�z���(���z�z���(���z�z���z�z��
�Z�Z�_�_��
$��D��:�:�$�$�T�*�D��:�:�?�?�$�D�%�;�D�J�J�<�H��
�	�&�&��
	
�����+�!��
	
��
	
���K��:�:�?�?�c�!���:�)�)�$��5�5�8�,�=�,�,�T�4�8�8r[)r�c��|j}|j}tt|�}|||fd|i|��\}}|j	||�S)Nr�)rOrQrr5rZ)rfr�r�r�r�rWrDs       rY�_accumulatezBaseMaskedArray._accumulatesP���z�z���z�z��
�)�4�
0����d�<�6�<�V�<�
��d�����d�+�+r[c	�F�ddlm}|j|�}||||��}	|j}
|	jdk7r|
j�}nt
j|t��}|dk(r|jd�dvrd	|dd|	j|jf||||
|d
�|��}|	jdk(rH|	jj|	jd�}
t
j||
df�j}|	jd
vr|S|j!||�S)Nr)�WrappedCythonOp)�howr��has_dropped_na�	aggregatern�rank�	na_option)�top�bottomF)r��ngroups�comp_idsrW�result_mask�ohlcr�)�idxmin�idxmax)�pandas.core.groupby.opsr��get_kind_from_howrQr�rer^rrtr�_cython_op_ndim_compatrOr��
_cython_arity�tiler�r�)rfr�r�r�r�idsr�r�r�rDrWr�
res_values�aritys              rY�_groupby_opzBaseMaskedArray._groupby_op!s��	<��0�0��5��
��4��
O���z�z��
�7�7�k�!��)�)�+�K��(�(�7�$�7�K��&�=�V�Z�Z��4�8I�I�"�K��N�.�R�.�.��J�J�
�����#�

��
�
��6�6�V���$�$�(�(�����3�E��'�'�+��q�z�:�<�<�K�
�6�6�)�)����*�*�:�{�C�Cr[)rVrNrWrP�returnr)F)rVrNrWrPrertr�None)rertrr)rcrr`r )ryrtrzCallable[[Any], str | None])rr')r�rrr)r�rrr)r�rrz
Self | Any)
r�rr��
int | Noner�z#Literal['inside', 'outside'] | Nonerertrr)NNNT)r�rrertrr)r`rrertrztuple[np.ndarray, np.ndarray])rr)rrt)rrA)r�int)rr)rr)r)r�rrr)r�r)rrN)r`znpt.DTypeLike | Nonerertr�r�rrN).)r`z
npt.DTypeLikerertrrN)r`r rertrr:)r`r
rertrr)T)NN)r`zNpDtype | Nonerezbool | NonerrN)r#znp.ufuncr�rxrS)rWznpt.NDArray[np.bool_] | NonerrP)rrE)rXz*np.ndarray | tuple[np.ndarray, np.ndarray]rWrN)rZzSequence[Self]r�rrr)r]rxr^rxr_rtrznpt.NDArray[np.uint64])rcrtrdz
Scalar | Noner�rrr)rVrrrE)r�)rozLiteral['first', 'last', False]rrP)r�N)r�z$NumpyValueArrayLike | ExtensionArrayrwzLiteral['left', 'right']rxzNumpySorter | Nonerznpt.NDArray[np.intp] | np.intp)r{rtrz!tuple[np.ndarray, ExtensionArray])r�rtrrC)r�rtrr)r�znpt.NDArray[np.float64]r�rxrrL)r�rxr�rtr�rt)r�rx)r�rtr�rr��AxisInt | None)r�rtr�r)r�rtr�rr�r)r�rr�rrertrrI)r�rxr�rtrrL)
r�rxr�rtr�rrrr
znpt.NDArray[np.intp])[r;�
__module__�__qualname__�__doc__�__annotations__rr�r��classmethodrZrgrlrr:rvrz�propertyr`rr�r�r�rjr�r�r�r�r�rcr�r�r�r�r�r�r�r�r�r�r�r�r	rr�r�r��__array_priority__r	r&r*r�r.rH�_logical_methodrNr�r*r"rWr[rbr4r1rerqruryr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r}r�r�r�r�r�r�
__classcell__)r�s@rYrLrLks����!� ��� � ��M��M�����MR�� ��(=��EI��	
��&�.2��!��!����	�	��	� ��	���(��(���������
;� !�:>��
*��*��	*�
8�*��
*�
�*�X	��	�	��NR��.8��GK��	
�� ��B�6;�'�'�'�/3�'�	&�'��'�
P�6�"/�� �� �� �����,�
,�
,�
&��<��<�B�F@�@��D�
.�
'+���>�>�	[�#�[��[��	[�

�[�z	��	�	��K� �K�������������,�\��AE�*�#�*�2=�*�	�*�%�$�K'�Z@�� �� ��0��	�� [5�z$�O�&6�P-�@�-�HR�-�^!��#��#��5��5����!����
�	������*-��;?��	��!�$(��
 .��	 .�
"� .��
 .�
� .�H6�(,�
	��	"�	"�#�6=�>�3�>�	�>�$�>�	/�	��	$�	$�%�*0�%)�	H�3�H�'�H�#�	H�

(�H�&�H� 	��	!�	!�"�!%�"!��"!�
+�"!�#�"!�H	��	+�	+�,��-��&B�P(�	��	�	��
P� �
P�';�)�';�:=�';�	�';�Z,0�%����$(��;?��4	�9�&S��S��� �
��
��	
�
�
�0�� �
��
��	
�
�
�*&*�!�U�!%�Q�A�T��T�,:�T�FI�T�!%�Q�A�T��T�,:�T�FI�T�%)��T�%)��T�G�%)��O+�b%)��P+�d29�#�29��	29��29�
�29�j,0�	,��	,�$(�	,�	�	,�-D��-D��	-D�
�-D��
-D�"�-Dr[rLc��t|�}|dj}|D�cgc]}|jjdd��� }}t	j
|dt	jt|�t|d�fd|j����}|D�cgc]}|jjdd��� }}t	j
|dt	j|t����}|j�}g}t|jd�D]+}	||dd�|	f|dd�|	f�	�}
|j|
��-|Scc}wcc}w)
z�Transpose 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.
    rr�r��F)�orderr`)r�rrnNr�)�listr`rOr�r^rYrpr�rrQ�
empty_likertrr�rcr)�
masked_arraysr`rrV�transposed_values�masks�transposed_masks�arr_type�transposed_arraysr��transposed_arrs           rY�#transpose_homogeneous_masked_arraysr+QsF����'�M��!��"�"�E�2?�
@�-�3�c�i�i����2�&�-�F�
@�����
��H�H�
��
��]�1�%5�!6�7���#�#�
���2?�?��#�S�Y�Y�
�
�q�"�
%��E�?��~�~�
�A�2�=�=�):�$�G����)�)�+�H�/1��
�$�*�*�1�-�
.��!�"3�A�q�D�"9�@P�QR�TU�QU�@V�W��� � ��0�/����-A��
@s�#E�#E)r$zSequence[BaseMaskedArray]rzlist[BaseMaskedArray])j�
__future__r�typingrrrrrr��numpyr^�pandas._libsr	r
r��pandas._libs.tslibsr�pandas._typingrr
rrrrrrrrrrrr�
pandas.compatrr�
pandas.errorsr�pandas.util._decoratorsr�pandas.util._validatorsr�pandas.core.dtypes.baser �pandas.core.dtypes.commonr!r"r#r$r%r&�pandas.core.dtypes.dtypesr'�pandas.core.dtypes.missingr(r)r*r+�pandas.corer,rpr-r.r/�pandas.core.algorithmsr0r1r2r3r4�pandas.core.array_algosr5r6� pandas.core.array_algos.quantiler7�pandas.core.arrayliker8�pandas.core.arrays._utilsr9�pandas.core.arrays.baser:�pandas.core.constructionr;r=r<r=�pandas.core.indexersr>�pandas.core.opsr?�pandas.core.util.hashingr@�collections.abcrArBr�rCrrErFrGrI�pandas.compat.numpyrJr�rLr+r~r[rY�<module>rGs���"������3����� �.�'�:�2���6��������@�*�>�2���
5�.�/����/��1�.�cD�h��cD�L/!�,�!��!r[

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists