Sindbad~EG File Manager

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

�

Mٜg�>���ddlmZddlmZmZddlZddlmZmZm	Z	m
Z
ddlZddlZ
ddlmZmZddlmZmZddlmZmZddlmZdd	lmZdd
lmZddlmZddl m!Z!dd
l"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0cm1Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddl<m=Z=ddl>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSerddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]Gd�deB�Z^Gd�dej�e^�Z_Gd�d e^eC�Z`		d-									d.d!�Za										d/d"�Zb	d0							d1d#�Zcd2d$�Zdd3d%�Zed4d&�Zfd5d'�Zgd6d(�Zh								d7d)�Zid8d*�Zj						d9d+�Zkd:d,�Zly);�)�annotations)�Hashable�SequenceN)�
TYPE_CHECKING�Callable�Literal�cast)�using_copy_on_write�warn_copy_on_write)�	internals�lib)�BlockPlacement�BlockValuesRefs)�	Timestamp)�PerformanceWarning)�cache_readonly)�find_stack_level)�infer_dtype_from_scalar)�ensure_platform_int�is_1d_only_ea_dtype�is_list_like)�DatetimeTZDtype�ExtensionDtype)�ABCDataFrame�	ABCSeries)�array_equals�isna)�ArrowExtensionArray�ArrowStringArray�
DatetimeArray)�NDArrayBackedExtensionArray)�ensure_wrapped_if_datetimelike�
extract_array)�maybe_convert_indices)�Index�ensure_index)�DataManager�SingleDataManager�ensure_np_dtype�interleaved_dtype)
�COW_WARNING_GENERAL_MSG�COW_WARNING_SETITEM_MSG�Block�
NumpyBlock�ensure_block_shape�
extend_blocks�get_block_type�maybe_coerce_values�	new_block�new_block_2d)�
blockwise_all�operate_blockwise)�	ArrayLike�AxisInt�DtypeObj�QuantileInterpolation�Self�Shape�npt)�ExtensionArrayc��eZdZUdZdZded<ded<ded<ded	<ed9d
��Zded<ded
<d:d;d�Ze	d<d��Z
ed=d��Zed=d��Zd>d?d�Z
d@d�ZeZdAd�ZdBd�Zed@d��ZedCd��ZdDd�ZdEd�ZdFd�ZdGd�ZdHd�ZedId��ZdJd�Z	d>			dKd �ZeZd:dLd!�ZdMd"�ZdNdOd$�ZdPd%�Z d&�Z!d'dd(�			dQd)�Z"ed@d*��Z#ed@d+��Z$dRd,�Z%d?d-�Z&d?d.�Z'd>dSd/�Z(ed9d0��Z)d:dTd1�Z*d?d2�Z+				dUd#d3�															dVd4�Z,e-j\d#fd#d#d5�									dWd6�Z/	dX					dYd7�Z0		dZ							d[d8�Z1y)\�BaseBlockManagera�
    Core internal data structure to implement DataFrame, Series, etc.

    Manage a bunch of labeled 2D mixed-type ndarrays. Essentially it's a
    lightweight blocked set of labeled data to be manipulated by the DataFrame
    public API class

    Attributes
    ----------
    shape
    ndim
    axes
    values
    items

    Methods
    -------
    set_axis(axis, new_labels)
    copy(deep=True)

    get_dtypes

    apply(func, axes, block_filter_fn)

    get_bool_data
    get_numeric_data

    get_slice(slice_like, axis)
    get(label)
    iget(loc)

    take(indexer, axis)
    reindex_axis(new_labels, axis)
    reindex_indexer(new_labels, indexer, axis)

    delete(label)
    insert(loc, label, value)
    set(label, value)

    Parameters
    ----------
    blocks: Sequence of Block
    axes: Sequence of Index
    verify_integrity: bool, default True

    Notes
    -----
    This is *not* a public API class
    ��npt.NDArray[np.intp]�_blknos�_blklocs�tuple[Block, ...]�blocks�list[Index]�axesc��t��N��NotImplementedError��selfs �I/usr/local/lib/python3.12/site-packages/pandas/core/internals/managers.py�ndimzBaseBlockManager.ndim����!�!��bool�_known_consolidated�_is_consolidatedc��t�rJrK)rNrFrH�verify_integritys    rO�__init__zBaseBlockManager.__init__�s��!�!rRc��t�rJrK��clsrFrHs   rO�from_blockszBaseBlockManager.from_blocks�rQrRc�R�|j�|j�|jS)a

        Suppose we want to find the array corresponding to our i'th column.

        blknos[i] identifies the block from self.blocks that contains this column.

        blklocs[i] identifies the column of interest within
        self.blocks[self.blknos[i]]
        )rC�_rebuild_blknos_and_blklocsrMs rO�blknoszBaseBlockManager.blknos�s$���<�<���,�,�.��|�|�rRc�R�|j�|j�|jS)z$
        See blknos.__doc__
        )rDr^rMs rO�blklocszBaseBlockManager.blklocs�s$��
�=�=� ��,�,�.��}�}�rRNc�N�|�tg�g|jddz}|jdk(r\t|t�sJ�|j
d}|jdd}ttdd��}|j||��}|g}ng}t|�j||�S)z9return an empty BlockManager with the items axis of len 0N�r��	placement)r%rHrP�
isinstance�SingleBlockManagerrF�valuesr�slice�make_block_same_class�typer\)rNrH�blk�arr�bp�nbrFs       rO�
make_emptyzBaseBlockManager.make_empty�s����<��"�I�;����1�2��.�D��9�9��>��d�$6�7�7�7��+�+�a�.�C��*�*�R�a�.�C���a���,�B��*�*�3�"�*�=�B��T�F��F��D�z�%�%�f�d�3�3rRc��y�NTrArMs rO�__nonzero__zBaseBlockManager.__nonzero__�s��rRc�6�|jdk(r	|dk(rdnd}|S)N�rrc�rP)rN�axiss  rO�_normalize_axisz BaseBlockManager._normalize_axis�s���9�9��>���	�1�q�D��rRc�F�|j||�||j|<yrJ)�_validate_set_axisrH)rNrw�
new_labelss   rO�set_axiszBaseBlockManager.set_axis�s������j�1�$��	�	�$�rRc�2�t|j�dk(S�Nrc��lenrFrMs rO�is_single_blockz BaseBlockManager.is_single_block�s���4�;�;��1�$�$rRc� �|jdS�Nr�rHrMs rO�itemszBaseBlockManager.items�����y�y��|�rRc�B�|j|}|j|�S)��
        Check for column `i` if it has references.
        (whether it references another array or is itself being referenced)
        Returns True if the column has no references.
        )r_�_has_no_reference_block)rN�i�blknos   rO�_has_no_referencez"BaseBlockManager._has_no_reference�s"�����A����+�+�E�2�2rRc�R�|j|jj�S)z�
        Check for block `i` if it has references.
        (whether it references another array or is itself being referenced)
        Returns True if the block has no references.
        �rF�refs�
has_reference)rNr�s  rOr�z(BaseBlockManager._has_no_reference_blocks%���;�;�u�%�*�*�8�8�:�:�:rRc��t|j�t|j�k7ryt|j�D]>\}}|j|j|_|jj	|��@y)z�
        Adds the references from one manager to another. We assume that both
        managers have the same block structure.
        N)r�rF�	enumerater��
add_reference)rN�mgrr�rls    rO�add_referenceszBaseBlockManager.add_referencess^��
�t�{�{��s�3�:�:��.������,�F�A�s��z�z�!�}�)�)�C�H��H�H�"�"�3�'�-rRc���|j|�t�fd�|j|jjD��S)zv
        Checks if two blocks from two different block managers reference the
        same underlying values.
        c3�0�K�|]
}�|�u���y�wrJrA)�.0�refrls  �rO�	<genexpr>z:BaseBlockManager.references_same_values.<locals>.<genexpr>s�����T�+S�C�3�#�%�<�+S�s�)rF�anyr��referenced_blocks)rNr�r�rls   @rO�references_same_valuesz'BaseBlockManager.references_same_valuess9���
�k�k�%� ���T�3�:�:�e�+<�+A�+A�+S�+S�T�T�TrRc��tj|jD�cgc]}|j��c}t��}|j|j�Scc}w�N��dtype)�np�arrayrFr��object�taker_�rNrl�dtypess   rO�
get_dtypeszBaseBlockManager.get_dtypessA��������<���3�9�9��<�F�K���{�{�4�;�;�'�'��=s�Ac�T�|jD�cgc]}|j��c}Scc}w)a�
        Quick access to the backing arrays of the Blocks.

        Only for compatibility with ArrayManager for testing convenience.
        Not to be used in actual code, and return value is not the same as the
        ArrayManager method (list of 1D arrays vs iterator of 2D ndarrays / 1D EAs).

        Warning! The returned arrays don't handle Copy-on-Write, so this should
        be used with caution (only in read-mode).
        )rFrh)rNrls  rO�arrayszBaseBlockManager.arrays#s$��'+�k�k�2�k�s��
�
�k�2�2��2s�%c���t|�j}t|j�D]\}}|dk(r	|d|��z
}�|d|�d|��z
}� |jD]
}|d|��z
}�|S)Nrz
Items: z
Axis z: �
)rk�__name__r�rHrF)rN�outputr��ax�blocks     rO�__repr__zBaseBlockManager.__repr__1s|���d��$�$���t�y�y�)�E�A�r��A�v��I�b�T�*�*���G�A�3�b���-�-��	*��[�[�E���5�'�l�"�F�!��
rRc��d|vsJ�|xsg}g}|D�cic]}|||��
}}|jD�]}|r�|j�D]�\}}t|ttf�ru|j
dk(r1|j|jjj||<�\|jdd�|jjfj||<��||jj||<��t|�r|j|fi|��}	nt||�di|��}	t|	|�}��t|�j||j �}
|
Scc}w)ab
        Iterate over the blocks, collect and create a new BlockManager.

        Parameters
        ----------
        f : str or callable
            Name of the Block method to apply.
        align_keys: List[str] or None, default None
        **kwargs
            Keywords to pass to `f`

        Returns
        -------
        BlockManager
        �filterrcNrA)rFr�rfrrrP�iloc�mgr_locs�indexer�_values�callable�apply�getattrr0rkr\rH)rN�f�
align_keys�kwargs�
result_blocks�k�aligned_args�b�obj�applied�outs           rOr�zBaseBlockManager.apply=sK��*�v�%�%�%��%�2�
�%'�
�/9�9�j���6�!�9��j��9����A��*�0�0�2�F�A�s�!�#�	�<�'@�A��8�8�q�=�(+������1C�1C�(D�(L�(L�F�1�I�(+����A�J�J�4F�4F�1F�(G�(O�(O�F�1�I�%(��
�
�(:�(:�$;��q�	�3���{�!�!�'�'�!�.�v�.��'�'�!�Q�-�1�&�1��)�'�=�A�M�%�(�4�j�$�$�]�D�I�I�>���
��/:s�
Ec���t|tj�r1|j|jkDrt	d|j����|rEt�r;|j
d�s*tjttt����nAt��r6|j
d��s$|jdk(�rt|t�r�|j|d}t|�r'|jdk(rtj |d��}nt|�s|g}t#|�dk(r|j%d��S|j&dj(}|jdk(rZ||}|j+d||�|j&dj-|dtj.t#|��f|�|S|j%�}|j1d	||�
�S)zi
        Set values with indexer.

        For SingleBlockManager, this backs s[indexer] = value
        zCannot set values with ndim > r��
stacklevelrurc�rwF��deep�setitem)r��value)rfr��ndarrayrP�
ValueErrorrr��warnings�warnr+�
FutureWarningrr
�tuplerar�squeezer��copyrFrh�_iset_split_blockr��aranger�)rNr�r�r��blk_locrhs      rOr�zBaseBlockManager.setitemts����g�r�z�z�*�w�|�|�d�i�i�/G��=�d�i�i�[�I�J�J��&�(��1G�1G��1J��M�M�'��+�-�
�!�
"�4�+A�+A�!�+D��y�y�A�~�*�W�e�"<��,�,�w�q�z�2����(�W�\�\�Q�->� �j�j��q�9�G�%�g�.�&�i�G��w�<�1�$��9�9�%�9�0�0����Q��.�.���;�;�!�#�#�G�_�F��*�*��7�F���K�K��N�*�*�G�A�J��	�	�#�g�,�8O�+P�RW�X��K��9�9�;�D��z�z�)�W�E�z�B�BrRc�(�|jd|��S)N�diff)�n�r�)rNr�s  rOr�zBaseBlockManager.diff�s���z�z�&�A�z�&�&rRFc�z�|�t�rd}nd}nt�rd}|jd|||t���S)NFT�astype)r�r��errors�	using_cow�r
r�)rNr�r�r�s    rOr�zBaseBlockManager.astype�sJ���<�"�$�����
 �
"��D��z�z�����)�+��
�	
rRc�v�|�t�rd}nd}nt�rd}|jd|t���S)NFT�convert�r�r�r�)rNr�s  rOr�zBaseBlockManager.convert�s;���<�"�$�����
 �
"��D��z�z�)�$�:M�:O�z�P�PrRc�\�t�rd}nd}|j	d|t�d�|��S)NFTr�)�convert_dtypesr�)rNr�r�s   rOr�zBaseBlockManager.convert_dtypes�s>��� ��D��D��t�z�z��
�#'�3F�3H�
�LR�
�	
rR�nan)�na_rep�quotingc�0�|jd|||||��S)z}
        Convert values to native types (strings / python objects) that are used
        in formatting (repr / csv).
        �get_values_for_csv)r�r��float_format�date_format�decimalr�)rNr�r�r�r�r�s      rOr�z#BaseBlockManager.get_values_for_csv�s,���z�z� ���%�#��
�
�	
rRc�:�td�|jD��S)z>Whether any of the blocks in this manager are extension blocksc3�4K�|]}|j���y�wrJ��is_extension�r�r�s  rOr�z7BaseBlockManager.any_extension_types.<locals>.<genexpr>�s����?�;�%�5�%�%�;�s�)r�rFrMs rO�any_extension_typesz$BaseBlockManager.any_extension_types�s���?�4�;�;�?�?�?rRc�f�t|j�dk(r|jdjSy)z8return a boolean if we are a single block and are a viewrcrF)r�rF�is_viewrMs rOr�zBaseBlockManager.is_view�s.���t�{�{��q� ��;�;�q�>�)�)�)�rRc��|jD�cgc]}||j�s�|��}}|j|�Scc}wrJ)rFrh�_combine)rN�	predicaterlrFs    rO�_get_data_subsetz!BaseBlockManager._get_data_subset�s:��!%���F��#�	�#�*�*�0E�#���F��}�}�V�$�$��Gs�>�>c��g}|jD]\}|jtk(r|j|��(|js�5|j�}|j
d�|D���^|j|�S)zs
        Select blocks that are bool-dtype and columns from object-dtype blocks
        that are all-bool.
        c3�:K�|]}|js�|���y�wrJ)�is_bool�r�ros  rOr�z1BaseBlockManager.get_bool_data.<locals>.<genexpr>s����!A�s��b�j�j�"�s�s��)rFr�rS�append�	is_object�_split�extendr�)rN�
new_blocksrl�nbss    rO�
get_bool_datazBaseBlockManager.get_bool_data�sh���
��;�;�C��y�y�D� ��!�!�#�&�����j�j�l���!�!�!A�s�!A�A�
��}�}�Z�(�(rRc��|jD�cgc]}|js�|��}}t|�t|j�k(r|S|j|�Scc}wrJ)rF�
is_numericr�r�)rNrl�numeric_blockss   rO�get_numeric_dataz!BaseBlockManager.get_numeric_datasP��)-���G��#����#���G��~��#�d�k�k�"2�2��K��}�}�^�,�,��	Hs
�A�Ac��t|�dk(rd|jdk(rE|�|jdd|g}n |jddg|jddz}|j	|�S|j	�Stjtj|D�cgc]}|jj��c}��}tj||jd�}g}|D]L}|jd��}t||jj�|_|j!|��Nt#|j�}|�||d<|jj%|�|d<t'|�j)||�Scc}w)z$return a new manager with the blocksrruNrcFr����)r�rPr�rHrpr��sort�concatenater��as_arrayr
�get_reverse_indexer�shaper�rr�r��listr�rkr\)	rNrF�indexrHr�r��inv_indexerrros	         rOr�zBaseBlockManager._combinesU���v�;�!���y�y�A�~��$� �J�J�r��N�E�2�D� �J�J�r��N�+�d�i�i���m�;�D����t�,�,��?�?�$�$��'�'�"�.�.�v�)N�v�!�!�*�*�*=�*=�v�)N�O�P���-�-�g�t�z�z�!�}�E��"$�
��A����U��#�B�(��R�[�[�5H�5H�)I�J�B�K����b�!��
�D�I�I������D��H��*�*�/�/�'�*��Q���D�z�%�%�j�$�7�7��*Os�Fc�,�t|j�SrJrrMs rO�nblockszBaseBlockManager.nblocks)s���4�;�;��rRc�����t�rd�nd��r%�fd�}|jD�cgc]
}||���}}nGt�r(|jD�cgc]}|j���}}nt|j�}|j	d���}||_|j
dkDrB|j}|�4|j�|_|jj�|_�r|j�|Scc}wcc}w)aN
        Make deep or shallow copy of BlockManager

        Parameters
        ----------
        deep : bool, string or None, default True
            If False or None, return a shallow copy (do not copy data)
            If 'all', copy data and a deep copy of the index

        Returns
        -------
        BlockManager
        FTc�R���dk(r|jd��S|j�S)N�allTr�)r��view)r�r�s �rO�	copy_funcz(BaseBlockManager.copy.<locals>.copy_funcGs%���-1�U�]�r�w�w�D�w�)�I����	�IrRr�r�rc)
r
rHrrr�rPrCr�rD�_consolidate_inplace)rNr�rr��new_axes�resr_s `     rOr�zBaseBlockManager.copy-s�����<�"�$������
J�15�	�	�:�	�"�	�"�
�	�H�:�"�$�04�	�	�:�	�"�B�G�G�I�	��:���	�	�?���j�j��d�j�+������9�9�q�=��\�\�F��!�$�k�k�m���#�}�}�1�1�3�����$�$�&��
��';��;s�D�Dc��|j�r|St|�|j|jd��}d|_|j�|S)zr
        Join together blocks having same dtype

        Returns
        -------
        y : BlockManager
        F�rW)�is_consolidatedrkrFrHrUr)rN�bms  rO�consolidatezBaseBlockManager.consolidate_sJ�����!��K�
�T�$�Z����T�Y�Y��
G��#���
���!��	rR)�use_na_proxyc��|�t�rd}nd}|�R||j|ur|s|S|j|��}	t|j�|	_||	j|<|	St	|t
j�sJ�|s|j|j|�||jk\rtd��|dk(r|j||||��}
n9|jD�cgc]$}|j|d|�|n|j����&}
}t|j�}|||<t|�j|
|�}
|dk(r>|j j�|
_|j$j�|
_|
Scc}w)	a?
        Parameters
        ----------
        new_axis : Index
        indexer : ndarray[intp] or None
        axis : int
        fill_value : object, default None
        allow_dups : bool, default False
        copy : bool or None, default True
            If None, regard as False to get shallow copy.
        only_slice : bool, default False
            Whether to take views, not copies, along columns.
        use_na_proxy : bool, default False
            Whether to use a np.void ndarray for newly introduced columns.

        pandas-indexer with -1's only.
        FTr��#Requested axis not found in managerr)�
fill_value�
only_slicer"rc)rwr%)r
rHr�rrfr�r��_validate_can_reindexrP�
IndexError�_slice_take_blocks_ax0rF�take_ndr%rkr\r_rCrarD)rN�new_axisr�rwr%�
allow_dupsr�r&r"�resultrrlr�new_mgrs              rO�reindex_indexerz BaseBlockManager.reindex_indexeros���:�<�"�$������?��4�9�9�T�?�*�4����Y�Y�D�Y�)�F��t�y�y�/�F�K� (�F�K�K����M��'�2�:�:�.�.�.���I�I�d�O�1�1�'�:��4�9�9���B�C�C��1�9��4�4��%�%�)�	5��J� �;�;�	�'�C������&0�&<�
�#�.�.�	��'�
�	���	�	�?��!�����t�*�(�(��X�>���1�9�"�k�k�.�.�0�G�O�#�|�|�0�0�2�G�����'	s�%)F
)r"�ref_inplace_opc��|tju}t||jd|��\}}}	|jr�|j
d}
|dk(r0|	dk(rgSt
td|	��}|
j||��gS|r|jdk(r�|r|�|
j}|sI|rGt|�D��
cgc]/\}}
|
jt|
|
dz�t
|�|����1}}}
|St
td|	��}|
j|d||��gS|dk(r|j|}|j|}nFtj|j|d|�	�}tj|j|d|�	�}g}|}t!j"||�
�D�]�\}}|dk(r$|j%|j'|||����0|j
|}
|
j(sc|
j*sW|xs
t-�}|D]B}|
j/|��}t
t||dz��|_|j%|��D��||j2}t5t7|�|j5�dz�}|s
t-�rtj8||�}t;|t�r&|
j||��}|j%|���;|rTt=||�D]C\}}
t||dz�}t
|
�}|
j||��}|j%|��E���|
j|d|�
�}|j%|����|Scc}
}w)a�
        Slice/take blocks along axis=0.

        Overloaded for SingleBlock

        Parameters
        ----------
        slice_or_indexer : slice or np.ndarray[int64]
        fill_value : scalar, default lib.no_default
        only_slice : bool, default False
            If True, we always return views on existing arrays, never copies.
            This is used when called from ops.blockwise.operate_blockwise.
        use_na_proxy : bool, default False
            Whether to use a np.void ndarray for newly introduced columns.
        ref_inplace_op: bool, default False
            Don't track refs if True because we operate inplace

        Returns
        -------
        new_blocks : list of Block
        r)�
allow_fillri)�new_mgr_locsrc)r3r0)rwr3r%r
)r%r2��group)rer%r"r�)rwr3)r
�
no_default�_preprocess_slice_or_indexerrr�rFrri�getitem_block_columnsrPr%r�r*r_ra�algos�libinternals�get_blkno_placementsr��_make_na_block�_can_consolidate�_validate_ndimr
r�r�r��maxr��maybe_indices_to_slicerf�zip)rN�slice_or_indexerr%r&r"r0r2�sl_type�slobj�sllenrlrnr��mlrFr_rar5r�r�r��mgr_loc�newblk�taker�max_lenro�slcs                           rOr)z'BaseBlockManager._slice_take_blocks_ax0�si��< �s�~�~�5�
� <��d�j�j��m�
�!
���������+�+�a�.�C��'�!��A�:��I�#�E�!�U�O�4���1�1�%�b�1�I�J�J��4�9�9��>��*�"4�!$���J�!�j�&/�u�%5�
�&6�E�A�r��1�1�!�"�b�1�f�-�)7��):�+9�2��
&6�
��"�M�'��a���8�B����!�!"�)+�'1�	$�����g���[�[��'�F��l�l�5�)�G��]�]����U�r�j��F��m�m����e��z��G������+�@�@��u�U�U�O�E�8���{��
�
��'�'�"*�#-�%1�(����k�k�%�(���+�+�C�4F�4F�
!+� C�.A�.C�D�D�#+��!$���t��!4��*8��w��RS��9T�*U����
�
�f�-�$,�$�H�$4�$4�5�E�!�#�h�-�����q��A�G�!�%8�%:� #� :� :�5�'� J��!�%��/� �6�6�u�8�6�T���
�
�b�)�#�&)���%9�E�A�r�"'��1�q�5�/�C�!/��!3�B�!$�!:�!:�3�R�!:�!P�B�"�M�M�"�-�&:�!�[�[��Q�X�[�N���
�
�b�)�a V�d�
��ks�54Mc�T�|rS|�J�t|�|jdf}tj|tj��}t||d��}|S|�tj}t|�|jdf}t|�\}}t|||�}t||��S)Nrcr�rurvrd)
r�rr��empty�voidr.r�r�
make_na_arrayr4)	rNrer%r"r�valsror��block_valuess	         rOr<zBaseBlockManager._make_na_blockPs���
��%�%�%���^�T�Z�Z��]�3�E��8�8�E����1�D��D�)�!�4�B��I������J��Y�����A��/��3�J�?���z�$�U�E�:�>���L�I�>�>rRc��|j|}t|||��}|j|j|�}|j	|||dd��S)ac
        Take items along any axis.

        indexer : np.ndarray[np.intp]
        axis : int, default 1
        verify : bool, default True
            Check that all entries are between 0 and len(self) - 1, inclusive.
            Pass verify=False if this check has been done by the caller.

        Returns
        -------
        BlockManager
        )�verifyTN)r+r�rwr,r�)rr$rHr�r/)rNr�rwrSr�r{s      rOr�zBaseBlockManager.takees_��*
�J�J�t���'���6�B���Y�Y�t�_�)�)�'�2�
��#�#������$�
�	
rR)�return�int�T)rWrSrT�None�rF�list[Block]rHrGrTr;)rTrBrJ�rTr;�rTrS)rwr8rTrU)rwr8r{r%rTrW�rTr%�r�rUrTrS)r�rUrTrS)r�r@rTrW)r�r@r�rUrTrS�rTznpt.NDArray[np.object_])rT�list[ArrayLike])rT�str)r�zlist[str] | NonerTr;)r�rSrTr;)r�rUrTr;)F�raise)r��bool | Noner�r`rTr;)r�rbrTr;)r�r`rTr;)r�rrTr;)rFrYrzIndex | NonerTr;)r�zbool | None | Literal['all']rTr;)NFTF)r+r%r�znpt.NDArray[np.intp] | Nonerwr8r,rSr�rbr&rSr"rSrTr;)
rB�slice | np.ndarrayr&rSr"rSr0rSrTrY)NF)rerr"rSrTr-)rcT)r�rBrwr8rSrSrTr;)2r��
__module__�__qualname__�__doc__�	__slots__�__annotations__�propertyrPrX�classmethodr\r_rarprs�__bool__rxr|r�r�r�r�r�r�r�r�r�r��apply_with_blockr�r�r�r�r�r�r�r�r�rrr�rr�r!r/r
r6r)r<r�rArRrOr@r@ls���0�d�I�
!�!�"�"���
��
�"��"�����"��"��"��
��
�����4�"��H��%�
�%��%�����3�;�
(�U�(��3��3�
�(,�2�%�2�

�2�j��+C�Z'�
�"	Q�
�DI�RV�
�=@�
�	
�
� �@��@�����%�)�$-�8�:� �� �0�d�*� � � �S�#�S��S�-�S��	S��
S��S��S��S�
�S�p�>�>� �	J�#�$�J�,�J��	J��
J��J�
�J�ZPU�?�'�?�HL�?�	�?�0��	
�%�
��
��	
�

�
rRr@c��eZdZdZdZ	d$							d%d�Zd&d�Zed'd��Zd(d�Z	d$d)d�Z
d*d�Zed+d	��Z
		d,									d-d�Z		d.									d/d
�Z	d0													d1d�Z	d2							d3d�Zd0d4d�Zd&d�Zd&d�Zd5d�Zd6d�Zd6d�Zd7d�Zd8d�Zdd�					d9d�Zd5d�Zd:d�Zdd
ej<f							d;d�Zdej<f					d<d�Z d=d�Z!d&d �Z"d&d!�Z#ed>d"��Z$ed>d#��Z%y)?�BlockManagerz0
    BaseBlockManager that holds 2D blocks.
    ruc��|rW|D]A}|j|jk7s�td|j�d|j�d���|j�yy)NzNumber of Block dimensions (z) must equal number of axes (�))rP�AssertionError�_verify_integrity)rNrFrHrWr�s     rOrXzBlockManager.__init__�sd��� ���9�9��
�
�*�(�6�u�z�z�l�C+�+/�9�9�+�Q�8��� �
�"�"�$�rRc�b�|j}td�|jD��}|jD]<}|jdd|ddk7s�t||jdd|j��>t|j�|k7r$tdt|j��d|����y)Nc3�FK�|]}t|j����y�wrJ)r�r�)r��xs  rOr�z1BlockManager._verify_integrity.<locals>.<genexpr>�s����=��A��A�J�J�����!rczINumber of manager items must equal union of block items
# manager items: z, # tot_items: )r�sumrF�raise_construction_errorrHr�r�rq)rN�	mgr_shape�	tot_itemsr�s    rOrrzBlockManager._verify_integrity�s����J�J�	��=����=�=�	��[�[�E��{�{�1�2��)�A�B�-�/�(��E�K�K���O�T�Y�Y�O�!��t�z�z�?�i�'� �1�14�T�Z�Z��0A�B�'�[�*��
�(rRc��|||d��S)�Z
        Constructor for BlockManager and SingleBlockManager with same signature.
        FrrArZs   rOr\zBlockManager.from_blocks�s��
�6�4�%�8�8rRc���t|j�dk(r�|jdjtd�|f�}t	tdt|���}t||d|jdj��}t||jd�St|jD�cgc]}|j��c}�}t|�}t|t�rtj|t��}n"tj||��}t!|�}|jD]5}t#|j$�D]\}}	|j||f�||	<��7t|t�r#|j'�}
|
j)||��}t	tdt|���}t||d��}t||jd�Scc}w)z�
        Return the array corresponding to `frame.iloc[loc]`.

        Parameters
        ----------
        loc : int

        Returns
        -------
        np.ndarray or ExtensionArray
        rcrN�rerPr�r��rerP)r�rF�igetrirr3r�rgrHr*r�rfrr�rMr�r"r�r��construct_array_type�_from_sequence)rN�locr-rnr�rlr�r�r��rlr[s           rO�fast_xszBlockManager.fast_xs�s����t�{�{��q� ��[�[��^�(�(�%��+�s�);�<�F���a��V�� 5�6�B������[�[��^�(�(�	�E�&�e�T�Y�Y�q�\�:�:�!����"D���3�9�9��"D�E����I���e�^�,�
�X�X�a�v�.�F��X�X�a�u�-�F�3�F�;�F��;�;�C�#�3�<�<�0���2� �X�X�q�#�h�/��r�
�1���e�^�,��,�,�.�C��'�'��e�'�<�F�
�E�!�S��[�1�
2���&�B�Q�7��!�%����1��6�6��5#Es�2G!c�*�|j|j|}|j|j|�}t	tdt
|���}t|�||d|r|jnd��}t||jd�S)z:
        Return the data as a SingleBlockManager.
        rrcNr~)rFr_r�rarrir�rkr�rgrH)rNr��	track_refr�rhrnros       rOr�zBlockManager.iget�s�����D�K�K��N�+�����D�L�L��O�,���E�!�S��[�1�
2��
�T�%�[��b�q�Y�u�z�z�D�
��"�"�d�i�i��l�3�3rRc�z�|j|j|}|j|j|�}|S)z�
        Return the data for column i as the values (ndarray or ExtensionArray).

        Warning! The returned array is a view but doesn't handle Copy-on-Write,
        so this should be used with caution.
        )rFr_r�ra)rNr�r�rhs    rO�iget_valueszBlockManager.iget_valuess5�����D�K�K��N�+�����D�L�L��O�,���
rRc��dgt|j�z}|jD][}|j}|jj�}|jdk(r	|||d<�At|�D]
\}}||||<��]|S)a'
        Used in the JSON C code to access column arrays.
        This optimizes compared to using `iget_values` by converting each

        Warning! This doesn't handle Copy-on-Write, so should be used with
        caution (current use case of consuming this in the JSON code is fine).
        Nrcr)r�r�rF�	_mgr_locs�array_values�_values_for_jsonrPr�)rNr-rlr�rhr�r�s       rO�
column_arrayszBlockManager.column_arrayss���,0�&�3�t�z�z�?�*B���;�;�C��}�}�H��%�%�6�6�8�F��{�{�a��&,��x��{�#�(��1�F�A�s�"(��)�F�3�K�2���
rRFNc�*	����|j�|jdkDr|j�t�j�}|sS�jdk(r
�j
�n
t
�d����jdd|jddk7rtd��tj|�r`tt|�}|j|}|j|}t|j �dk(r|j#|�|||���S|g}|r�fd�}n�fd�}|j|}	|j$|j'�}
g}g}g�t)j*|	d	�
�D�]\}
}|j|
}|
|j,}|ra|j/��rPt1�r-|j3|
�s|j5|
|||�����o|j7|||����|j9|j:j<|�|j9|�t|�t|j:�k(r�j9|
���|j5|
|�����
t��r�t?j@|jBt>jD��}d	|�<t?jF|jBt>jH��}|jKd
�t?jL|jBt��z
�||<||jN|_'tQ�fd�tS|j�D��|_|�r4t?jT|�}t|�}g}|rc|jW��fd�|D��t?jL|�t|j�z|jN|<d|j|<n�|dj9|dd�}|j9tY||�t[|�����t|j�|jN|<t?jL|�|j|<|xjtQ|�z
c_d|_.yy)z�
        Set new item in-place. Does not consolidate. Adds new Block if not
        contained in the current set of items
        Nrcrurvz9Shape of new values must be compatible with manager shape)�inplacer�rlr�c����SrJrA�rer�s �rO�
value_getitemz(BlockManager.iset.<locals>.value_getitemcs����rRc�"���|jSrJ)r�r�s �rOr�z(BlockManager.iset.<locals>.value_getitemhs����Y�.�.�/�/rRTr4�r�r�r
c3�D�K�|]\}}|t��vs�|���y�wrJ)�set)r�r�rl�removed_blknoss   �rOr�z$BlockManager.iset.<locals>.<genexpr>�s&����� �"8���3�A�S��EX�<X��"8�s� � c3�f�K�|](}t�tt||dz��������*y�w)rc�rhrer�N)r4rri)r�rGr�r�s  ��rOr�z$BlockManager.iset.<locals>.<genexpr>�s@�����"�$.��!�$�"0��w��!��1L�"M�!���
$.�s�.1rr�F)/rDrPr^rr��Tr/rrqr
�
is_integerr	rUr_rFr�r��_iset_singlerar�r:r;r��should_storer
r�r��set_inplacer�r�r
r��zerosr�bool_rM�intp�fillr�rCr�r�rrr4rrT)rNr�r�r�r��value_is_extension_typer�rlr�r_ra�unfit_mgr_locs�unfit_val_locs�blkno_l�val_locs�blk_locs�
is_deleted�
new_blknos�
unfit_idxr�unfit_countr�unfit_val_itemsr�s  ` `                 @rO�isetzBlockManager.iset*s����=�=� �T�Y�Y��]��,�,�.�#6�e�k�k�"B��&��z�z�Q������*�5�q�9���{�{�1�2��$�*�*�Q�R�.�0�$�O����>�>�#���s�C�.�C��K�K��$�E��+�+�e�$�C��3�=�=�!�Q�&��(�(���#����
)����%�C�#�
�

0����S�!���,�,�s�#�(�(�*��������!-�!B�!B�6�QU�!V�!V��G�X��+�+�g�&�C��x�/�/�0�H��3�+�+�E�2�&�(��1M�1M�g�1V��*�*���=��+B��+���O�O�H�m�H�.E�F���%�%�c�l�l�&;�&;�H�&E�F��%�%�h�/��x�=�C����$5�5�"�)�)�'�2���*�*�7�H�4�*�H�-"W�0�~�����$�,�,�b�h�h�?�J�)-�J�~�&����$�,�,�b�g�g�>�J��O�O�B��&(�i�i����s�>�?R�0R�&S�J�
�{�#�%�d�l�l�3�D�L�� �"+�D�K�K�"8� ��D�K������7�J��j�/�K�&(�J�&��!�!�"�$.�
"��,.�9�9�[�+A�C����DT�+T����Z�(�,-��
�
�j�)�#1��"3�":�":�>�!�"�;M�"N���!�!� �,�_�=�"0��"<�!���,/�t�{�{�+;����Z�(�,.�I�I�k�,B��
�
�j�)��K�K�5��,�,�K�(-�D�$�OrRc��|j|}|j�|j�t|j	|��}|�1|j
j|}t|t|�|��}n|d}t|dd�}t|j�}	|jd||fz|j|dzdz|z}
|
|_|s|�ytjt|��|j|j
j<t|�D]j\}}tjt|��|j|j
j<||	z|j|j
j<�ly)a?Removes columns from a block by splitting the block.

        Avoids copying the whole block through slicing and updates the manager
        after determinint the new block structure. Optionally adds a new block,
        otherwise has to be done by the caller.

        Parameters
        ----------
        blkno_l: The block number to operate on, relevant for updating the manager
        blk_locs: The locations of our block that should be deleted.
        value: The value to set as a replacement.
        refs: The reference tracking object of the value to set.
        Nr�rrc)rFrDr^r��deleter�r
r4rr�r�r�r�r�rC)
rNr�r�r�r�rl�nbs_tup�locs�first_nb�	nr_blocks�
blocks_tupr�ros
             rOr�zBlockManager._iset_split_block�sQ��(�k�k�'�"���=�=� ��,�,�.���
�
�8�,�-�����<�<�(�(��2�D�#�E�>�$�+?�d�K�H��q�z�H��G�A�B�K�(�G�����$�	��K�K���!�X�K�/�$�+�+�g��k�m�2L�L�w�V�	�!����5�,��35�9�9�S��]�3K��
�
�h�'�'�/�/�0��w�'�E�A�r�13���3�r�7�1C�D�M�M�"�+�+�-�-�.�01�I�
�D�L�L����,�,�-�(rRc�D�|ra|j|�rPd}t�r|j|�sd}|j|}|j	t||dz�||��yt
||j|��}	|j}
|
d||	fz|
|dzdz}||_y)z�
        Fastpath for iset when we are only setting a single position and
        the Block currently in that position is itself single-column.

        In this case we can swap out the entire Block and blklocs and blknos
        are unaffected.
        FTrc)r�N�rer�)	r�r
r�rar�rir4r�rF)rNr�r�r�r�rlr�r�r�ro�
old_blocksrs            rOr�zBlockManager._iset_single�s���$�s�'�'��.��D�"�$�T�-I�-I�%�-P����<�<��$�D��O�O�E�$��q��1�5�t�O�D��
�%�3�=�=�t�
D���[�[�
����'�2�%�/�*�U�Q�Y�[�2I�I�
� ���rRc���d}t�rN|j|�s=t|j|j|j
ttf�s�d}n�t�r�|j|�sq|j|}|j|}|j|j
}|jdk(r|j�}n||g}|j||g|�|j|d��}	|r|	j||�n;|	j|f|�}
|j!||
j"j
d��|r)t%j&t(t*t-���yy)z�
        Set values ("setitem") into a single column (not setting the full column).

        This is a method on the BlockManager level, to avoid creating an
        intermediate Series at the DataFrame level (`s = df[loc]; s[idx] = value`)
        FTrc)r�)r�r�N)rr�rfrFr_rhrrr
rarPr�r�r��setitem_inplacer�r��_blockr�r�r+r�r)rNr��idxr��inplace_only�
needs_to_warnr�r�rh�col_mgrr.s           rO�column_setitemzBlockManager.column_setitems@���
����(>�(>�s�(C�����D�K�K��,�-�4�4�$�&6�7��!%�
�
 �
"�4�+A�+A�#�+F��K�K��$�E��l�l�3�'�G��[�[��'�.�.�F��{�{�a������� ��	�*���"�"�5�7�)�V�<��)�)�C�5�)�1����#�#�C��/��o�o�s�f�e�4�G��I�I�c�7�>�>�0�0�$�I�?���M�M�'��+�-�
�rRc���tj�5tjddt��|jj||�}ddd�|jdk(r<|j}t|�dkDr9td|jj����t||j��}tt||dz��}t|||�	�}t|j�sWt!j"d
gt j$��|_t!j"d
gt j$��|_n"|j+|�|j-|�|j.d
<|xj|fz
c_d|_t3d
�|jD��dkDr%tj4dt6t9���yy#1swY���xYw)z�
        Insert item at selected position.

        Parameters
        ----------
        loc : int
        item : hashable
        value : np.ndarray or ExtensionArray
        refs : The reference tracking object of the value to set.
        �ignorez<The behavior of Index.insert with object-dtype is deprecated)�categoryNrurcz-Expected a 1D array, got an array with shape rvr�rr�Fc3�6K�|]}|j���y�wrJr�r�s  rOr�z&BlockManager.insert.<locals>.<genexpr>ps����?�;�%�5�%�%�%�;�s��daDataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`r�)r��catch_warnings�filterwarningsr�r��insertrPr�r�r�rr/rrir4rFr�r�r�rDrC�_insert_update_mgr_locs�!_insert_update_blklocs_and_blknosrHrTrwr�rr)rNr��itemr�r�r+rnr�s        rOr�zBlockManager.insertCsz���
$�
$�
&��#�#��N�&�
�
�z�z�(�(��d�3�H�'��:�:��?��G�G�E��5�z�A�~� �C�E�G�G�M�M�?�S���'�u�4�9�9�=�E�
�E�#�s�Q�w�/�
0���E�R�d�C���4�;�;���H�H�a�S����8�D�M��8�8�Q�C�r�w�w�7�D�L��(�(��-��2�2�3�7���	�	�!������x���#(�� ��?�4�;�;�?�?�#�E��M�M�W�#�+�-�

�F�E'�
&�s�9G�G'c��t|j|d�D]4\}}|j|}|jj	|�|_�6y)z�
        When inserting a new Block at location 'loc', we increment
        all of the mgr_locs of blocks above that by one.
        N)�_fast_count_smallintsr_rFr��increment_above)rNr�r��countrls     rOr�z$BlockManager._insert_update_mgr_locszsG��
2�$�+�+�c�d�2C�D�L�E�5��+�+�e�$�C��M�M�9�9�#�>�C�M�ErRc��||jjdk(r^tj|jd�|_tj|j
t
|j��|_y|dk(rvtj|jddd�d�ddd�|_tj|j
ddd�t
|j��ddd�|_ytj|j|j|t
|j��\}}||_||_y)zk
        When inserting a new Block at location 'loc', we update our
        _blklocs and _blknos.
        rNr
)rarr�r�rDrCr�rFr:�update_blklocs_and_blknosr_)rNr��new_blklocsr�s    rOr�z.BlockManager._insert_update_blklocs_and_blknos�s����$�,�,�$�$�Q�'�'��I�I�d�m�m�Q�7�D�M��9�9�T�\�\�3�t�{�{�3C�D�D�L�
�A�X��I�I�d�m�m�D�b�D�&9�1�=�d��d�C�D�M��9�9�T�\�\�$�B�$�%7��T�[�[�9I�J�4�R�4�P�D�L�&2�&L�&L����d�k�k�3��D�K�K�0@�'�#�K��(�D�M�%�D�LrRc�<�tj|jdtj��}d||<|j	�d}|j|dd��}|j|}||jdg}t|�t|�|d��S)zJ
        Delete selected locations, returning a new BlockManager.
        rr�T)r&r0rcFr)
r�r�rr��nonzeror)r�rHrkr�)rNr�r�rIr�new_columnsrHs       rO�ideletezBlockManager.idelete�s����X�X�d�j�j��m�2�8�8�<�
�"�
�7����%�%�'��*���)�)�%�D�QU�)�V���j�j�*��-���T�Y�Y�q�\�*���t�D�z�%��*�d�U�C�CrRc��g}|jD]^}|jr3|j�D]}|j|�}t	||�}�!�B|j|�}t	||�}�`t|�dk(rd}n|djjd}tt|��}t|�j||jd|g�S)z�
        Apply grouped reduction function blockwise, returning a new BlockManager.

        Parameters
        ----------
        func : grouped reduction function

        Returns
        -------
        BlockManager
        rr
)
rFr�rr�r0r�rhrr%�rangerkr\rH)rN�funcr�rl�sbr��nrowsrs        rO�grouped_reducezBlockManager.grouped_reduce�s���&(�
��;�;�C��}�}��*�*�,�B� �h�h�t�n�G�$1�'�=�$I�M�'��)�)�D�/�� -�g�}� E�
���}���"��E�!�!�$�+�+�1�1�"�5�E��e�E�l�#���D�z�%�%�m�d�i�i��l�E�5J�K�KrRc��|jdk(sJ�g}|jD]$}|j|�}|j|��&t	dg�}t|�j
||j|g�}|S)z�
        Apply reduction function blockwise, returning a single-row BlockManager.

        Parameters
        ----------
        func : reduction function

        Returns
        -------
        BlockManager
        ruN)rPrF�reducerr%rkr\r�)rNr��
res_blocksrlrrr.s       rOr�zBlockManager.reduce�st���y�y�A�~��~�"$�
��;�;�C��*�*�T�"�C����c�"���t�f�
���t�*�(�(��d�j�j�%�5H�I���rRc��t|||�S)zO
        Apply array_op blockwise with another (aligned) BlockManager.
        )r6)rN�other�array_ops   rOr6zBlockManager.operate_blockwise�s��!��u�h�7�7rRc�$�t||t�S)��
        Used in .equals defined in base class. Only check the column values
        assuming shape and indexes have already been checked.
        )r5r)rNr�s  rO�
_equal_valueszBlockManager._equal_values�s��
�T�5�,�7�7rR�linear)�
interpolationc�&�|jdk\sJ�t|�sJ�t|j�}t	|t
j��|d<|jD�cgc]}|j||����}}t|�||�Scc}w)a�
        Iterate over blocks applying quantile reduction.
        This routine is intended for reduction type operations and
        will do inference on the generated blocks.

        Parameters
        ----------
        interpolation : type of interpolation, default 'linear'
        qs : list of the quantiles to be computed

        Returns
        -------
        BlockManager
        rur�rc)�qsr�)
rPrrrHr%r��float64rF�quantilerk)rNr�r�rrlrFs      rOr�zBlockManager.quantile�s���,�y�y�A�~��~��B������	�	�?���B�b�j�j�1����IM���
�HS��C�L�L�B�m�L�<��	�
��t�D�z�&�(�+�+��	
s� Bc�*�|j|j�}|j}|j}|r7|jj
|j�}|jd��}n(tj|jdt��}g}g}	t|j�dk(rd}
n<t|�t|j�z}|t|�k(sJ�t|�}
|jD]~}|j}
|
j|
�}|j!||||��\}}|j#|�|	j#|�|j%�t%d�|D��k(r�~J�||	}t'|||gd��}|S)	a'
        Return a BlockManager with all blocks unstacked.

        Parameters
        ----------
        unstacker : reshape._Unstacker
        fill_value : Any
            fill_value for newly introduced missing values.

        Returns
        -------
        unstacked : BlockManager
        rr�rcr�)�
new_placement�
needs_maskingc3�FK�|]}t|j����y�wrJ)r�r�r�s  rOr�z'BlockManager.unstack.<locals>.<genexpr>Gs����$H��2�S����%6��rvFr)�get_new_columnsr��	new_index�mask_all�mask�reshape�
full_shaper�r�r�rSr�rUrFr��tile_for_unstack�_unstackrrwrn)rN�	unstackerr%r�r�r2�
new_mask2Dr�r�columns_mask�factor�facrlr�r�rFr�r s                  rO�unstackzBlockManager.unstacks|�� �/�/��
�
�;���'�'�	�"�+�+�+�
��3�9�>�>�/�2�2�I�4H�4H�I�J�&�N�N��N�2�M��H�H�Y�%9�%9�!�%<�D�I�M�"$�
�)+���t�z�z�?�a���F��k�"�S����_�4�C��#�c�(�?�"�?���X�F��;�;�C��|�|�H�$�5�5�f�=�M��<�<���+�+�	(��L�F�D�
���f�%�����%��8�8�:��$H��$H�!H�H�H�H��("�,�/��
�*�{�I�&>�QV�
W���	rRc��i}|jD]6}|jt|j�g�j	|��8|j�D��cic]\}}||j
|���c}}Scc}}w)z�
        Return a dict of str(dtype) -> BlockManager

        Returns
        -------
        values : a dict of dtype -> BlockManager
        )rF�
setdefaultr`r�r�r�r�)rN�bdr�r�rFs     rO�to_dictzBlockManager.to_dictQsl��&(�����A��M�M�#�a�g�g�,��+�2�2�1�5��CE�(�(�*�M�*�����t�}�}�V�,�,�*�M�M��Ms�A;c���tj|�xrt|�}t|j�dk(r5tj|jt��}|j�S|jr�|jd}|tjur%tj|jd�r|rnd}|jr8|jj!|||��j#|j�}nF|s"tj$|j|��}n"tj&|j||��}t)�r7|s5|j+�}d|j,_n|j1||��}|tjur	|j�S|jj2dk(r|r	|j�S||t|�<|j�S)	a-
        Convert the blockmanager data into an numpy array.

        Parameters
        ----------
        dtype : np.dtype or None, default None
            Data type of the return array.
        copy : bool, default False
            If True then guarantee that a copy is returned. A value of
            False does not guarantee that the underlying data is not
            copied.
        na_value : object, default lib.no_default
            Value to be used as the missing value sentinel.

        Returns
        -------
        arr : ndarray
        rr�r�T)r��na_valuer�)r�r�F�r�r)r
�is_floatrr�rFr�rMr�float�	transposer�r6�is_np_dtyper�r�rh�to_numpyr��asarrayr�r
r�flags�	writeable�_interleave�kind)rNr�r�r�
passed_nanrmrls       rOr
zBlockManager.as_arrayas���0�\�\�(�+�>��X��
��t�{�{��q� ��(�(�4�:�:�U�3�C��=�=�?�"�����+�+�a�.�C��s�~�~�-��?�?�3�9�9�c�2�z���D����
�j�j�)�)��%��*���'�#�)�)�$�	�
��j�j����5�9���h�h�s�z�z��T�B��"�$�T��h�h�j��&+��	�	�#��"�"���"�B�C��s�~�~�%���}�}����Y�Y�^�^�s�
"�z���}�}���&�C��S�	�N��}�}��rRc��|s-t|jD�cgc]}|j��c}�}t|�}t	j
|j|��}t	j|jd�}|t	jd�k(r`|tjurN|jD]=}|j}|j|�}|||j<d||j<�?|S|jD]g}|j}|jr|jj||��}n|j|�}|||j<d||j<�i|j!�st#d��|Scc}w)zt
        Return ndarray from blocks with specified item order
        Items must be contained in the blocks
        r�rr�rcrz'Some items were not contained in blocks)r*rFr�r)r�rMrr�r
r6r��
get_valuesr�r�rhr
rrq)rNr�rrlr-�itemmaskr�rms        rOrzBlockManager._interleave�sV���&�&*�k�k�2�k�s����k�2��E� ��&�����$�*�*�E�2���8�8�D�J�J�q�M�*���B�H�H�X�&�&�8�s�~�~�+E��{�{���\�\���n�n�U�+��%(��r�z�z�"�'(�����$�	#�
�M��;�;�C����B����
�j�j�)�)��%�*���
�n�n�U�+��!$�F�2�:�:��#$�H�R�Z�Z� �� �|�|�~� �!J�K�K��
��M3s�F	c�R�|js|j�|jS)zH
        Return True if more than one block with the same dtype
        )rT�_consolidate_checkrUrMs rOrzBlockManager.is_consolidated�s%���'�'��#�#�%��$�$�$rRc��t|j�dk(rd|_d|_y|jD�cgc]}|js�|j
��}}t|�tt
|��k(|_d|_ycc}w)NrcT)r�rFrUrTr=r�r�r�s   rOrzBlockManager._consolidate_check�sr���t�{�{��q� �$(�D�!�'+�D�$��'+�{�{�K�{��c�6J�6J�#�)�)�{��K� #�F��s�3�v�;�/?� ?���#'�� ��Ls�B�Bc��|j�s9t|j�|_d|_d|_|j�yyrr)r�_consolidaterFrUrTr^rMs rOrz!BlockManager._consolidate_inplace�sA��
�#�#�%�&�t�{�{�3�D�K�$(�D�!�'+�D�$��,�,�.�	&rRc�(�d}g}|D]v}|jD]M}|jtd��}|jj	|�|_|j|��O|t
|j�z
}�x|t|�|�}|S)zK
        Concatenate uniformly-indexed BlockManagers horizontally.
        rN)	rF�slice_block_columnsrir��addr�r�r�r�)	r[�mgrsrH�offsetrFr�rlror.s	         rO�concat_horizontalzBlockManager.concat_horizontals���
�� ���C��z�z���,�,�U�4�[�9��!�|�|�/�/��7����
�
�b�!�
"�
�c�#�)�)�n�$�F���e�F�m�T�*���rRc��td��)zI
        Concatenate uniformly-indexed BlockManagers vertically.
        z.This logic lives (for now) in internals.concatrK)r[rrHs   rO�concat_verticalzBlockManager.concat_verticals��
"�"R�S�SrRrV)rFzSequence[Block]rHzSequence[Index]rWrSrTrW�rTrWrX)r�rUrTrg)r�rUr�rSrTrg)r�rUrTr7)rTzlist[np.ndarray])FN)
r��int | slice | np.ndarrayr�r7r�rSr��BlockValuesRefs | NonerTrW)NN)
r�rUr�znp.ndarray | list[int]r�zArrayLike | Noner�r#rTrWrJ)r�rUr�r7r�rSr�rUrlr-r�r#rTrW�F)r�rUr�r"r�rSrTrW)r�rUr�rr�r7rTrW)rTrn)r�rrTr;)r�rnrTrn)rNrnr�rnrTrS)r�r%r�r:rTr;)rTzdict[str, Self])r��np.dtype | Noner�rSrr�rT�
np.ndarray)r�r%rr�rTr&r[)rz
list[Self]rHrGrTr;)&r�rdrerfrPrXrrrjr\r�r�r�rir�r�r�r�r�r�r�r�r�r�r�r6r�r�r�rr
r6r
rrrrrr rArRrOrnrn�s����
�D�"&�	%��%��%��	%�

�%�,��9��9�47�l4�
�����>�'+�T-�
%�T-��T-��	T-�
%�T-�
�
T-�t#'�'+�/>��/>�)�/>� �	/>�
%�/>�
�
/>�p(,��
�����	�
���
�%��
��DTY�/��/�5�/�LP�/�	
�/�b5�n?�&�,D� L�B�08�8�08�	 ,�
� ,�-�	 ,�

� ,�H;�zN�$"&���>�>�	H��H��H��	H�

�H�X"&��>�>�4��4��4�
�	4�r%�(�	/�����(�T��TrRrnc���eZdZdZedd��ZdZdZdZdZ		d 							d!d�Z
e						d"d��Ze	d#							d$d��Z
d%d�Zd&d'd	�Zd
�Zd(d�Zd(d�Zed)d
��Zed��Zed��Zd*d�Zd&d+d�Zed,d��Zed-d��Zd.d�Zd�Zd�Zd/d�Zd0d�Zed1d��Z d2d3�fd�
Z!d4d�Z"d�Z#d5d�Z$d6d�Z%�xZ&S)7rgzmanage a single block withc��yr~rArMs rOrPzSingleBlockManager.ndim$s��rRTrAc�$�|g|_|f|_yrJ�rHrF)rNr�rwrWs    rOrXzSingleBlockManager.__init__-s���F��	��h��rRc�d�t|�dk(sJ�t|�dk(sJ�||d|dd��S)r|rcrFr�r�rZs   rOr\zSingleBlockManager.from_blocks:s=���6�{�a�����4�y�A�~��~��6�!�9�d�1�g��>�>rRc��t|�}ttdt|���}t	||d|��}|||�S)zN
        Constructor for if we have an array that is not yet a Block.
        rrcr~)r2rrir�r3)r[r�rr�rnr�s      rO�
from_arrayzSingleBlockManager.from_arrayGs@��$�E�*��
�E�!�S��Z�0�
1���%�2�A�D�A���5�%� � rRc���|jd}t|jd��}td�}t	|�||d|j
��}||jdg}t|g|d��S)z5
        Manager analogue of Series.to_frame
        rrurvr~F)rHrW)rFr/rhrrkr�rHrn)rN�columnsrlrmrn�new_blkrHs       rO�	to_2d_mgrzSingleBlockManager.to_2d_mgrSsh���k�k�!�n�� ����!�4��
�A�
���$�s�)�C�2�A�C�H�H�E������1��&���W�I�D�5�I�IrRc�R�|jdjj�S)r�rr�)rNr�s  rOr�z$SingleBlockManager._has_no_reference^s$���;�;�q�>�&�&�4�4�6�6�6rRc��|jD�cgc]}|j��}}|jD�cgc]%}|j|jj��'}}t|j�}d||jD�cgc]%}|j|jjd���'c}d�i}||||fScc}wcc}wcc}w)N�0.14.1)rhr�r*)rFrhr�r�r�rrH)rNr�rQ�block_items�
axes_array�extra_states      rO�__getstate__zSingleBlockManager.__getstate__fs���*.�+�+�6�+�Q����+��6�?C�{�{�K�{�!�t�z�z�!�*�*�"4�"4�5�{��K��$�)�)�_�
�
�"�"�[�[��(�� !�x�x�Q�Z�Z�5G�5G�H�(���
���<��k�A�A��!7��K��s�B9�*B>�*Cc�R���d	d��t|t�rqt|�dk\rcd|dvr\|dd}|dD�cgc]
}t|���c}|_t|j��t��fd�|dD��|_nt
d��|j�ycc}w)
Nc��t|d��}t|t�st|�}t|�}t	|||��S)NT)�
extract_numpyr)r#rfrr2r3)rhr�rPs   rO�unpickle_blockz7SingleBlockManager.__setstate__.<locals>.unpickle_blockzs=��#�6��>�F��h��7�)�(�3��(��0�F��V�x�d�C�CrR�r5�rHc3�@�K�|]}�|d|d������y�w)rhr�rvNrA)r�r�rPr=s  ��rOr�z2SingleBlockManager.__setstate__.<locals>.<genexpr>�s-����� �(�A��q��{�A�j�M��E�E�(�s�rFz*pre-0.14.1 pickles are no longer supported)rPrUrTr-)rfr�r�r&rHrFrL�_post_setstate)rN�stater�rPr=s   @@rO�__setstate__zSingleBlockManager.__setstate__ys����	D��e�U�#��E�
�a��H��a��<P��!�H�X�&�E�49�&�M�B�M�b��b�)�M�B�D�I��t�y�y�>�D�� ��x�� ��D�K�
&�&R�S�S������Cs�B$c��yrJrArMs rOrAz!SingleBlockManager._post_setstate�s��rRc� �|jdSr�)rFrMs rOr�zSingleBlockManager._block�s���{�{�1�~�rRc��y�zcompat with BlockManagerNrArMs rOrCzSingleBlockManager._blknos����rRc��yrGrArMs rOrDzSingleBlockManager._blklocs�rHrRc��|j}t�rJt|�dkDr<|j�r,t	|�|jd��|j�S|j|}t|tj�r|jjdk(rd}n|j}ttdt|���}t	|�||d|��}|j|}t	|�||�S)NrFr�r�rcr~)r�r
r�rrkr�rrhrfr�r�r�rr�rri)rNr�rlr�r�rnr��new_idxs        rO�get_rows_with_maskz%SingleBlockManager.get_rows_with_mask�s����k�k��� �S��\�A�%5�'�+�+�-��4��:�c�h�h�E�h�2�D�J�J�?�?��
�
�7�#���g�r�z�z�*�w�}�}�/A�/A�S�/H��D��8�8�D�
�E�!�S��Z�0�
1����S�	�%�2�A�D�A���*�*�W�%���t�D�z�%��)�)rRc�@�||jk\rtd��|j}|j|}t	tdt
|���}t|�||d|j��}|jj|�}t|�||�S)Nr$rrcr~)rPr(r�rhrrir�rkr�r�_getitem_slice)rNrDrwrlr�rnr�r�s        rO�	get_slicezSingleBlockManager.get_slice�s����4�9�9���B�C�C��k�k���
�
�5�!��
�E�!�S��Z�0�
1����S�	�%�2�A�C�H�H�E���J�J�-�-�e�4�	��t�D�z�%��+�+rRc� �|jdSr�r�rMs rOrzSingleBlockManager.index�r�rRc�.�|jjSrJ)r�r�rMs rOr�zSingleBlockManager.dtype�s���{�{� � � rRc�b�tj|jjgt��Sr�)r�r�r�r�r�rMs rOr�zSingleBlockManager.get_dtypes�s ���x�x����*�*�+�6�:�:rRc�6�|jj�S)z$The array that Series.values returns)r��external_valuesrMs rOrTz"SingleBlockManager.external_values�s���{�{�*�*�,�,rRc�.�|jjS)z%The array that Series._values returns)r�rhrMs rO�internal_valuesz"SingleBlockManager.internal_values�s���{�{�!�!�!rRc�.�|jjS)z#The array that Series.array returns)r�r�rMs rOr�zSingleBlockManager.array_values�����{�{�'�'�'rRc�r�|jjr|jd��S|j�S)NFr�)r�rr�rprMs rOrz#SingleBlockManager.get_numeric_data�s-���;�;�!�!��9�9�%�9�(�(���� � rRc�.�|jjSrJ)r��_can_hold_narMs rOr[zSingleBlockManager._can_hold_na�rXrRc�J��t�}t�}|s|rz|jd�si|r;|jj	�f|_|jj�n,|r*|r(tjttt���t�|�9||�y)a'
        Set values with indexer.

        For Single[Block/Array]Manager, this backs s[indexer] = value

        This is an inplace version of `setitem()`, mutating the manager/values
        in place, not returning a new Manager (and Block), and thus never changing
        the dtype.
        rr�N)r
rr�r�r�rF�_cache�clearr�r�r,r�r�superr�)rNr�r�r�r��warn_cow�	__class__s      �rOr�z"SingleBlockManager.setitem_inplace�s���(�)�	�%�'����4�+A�+A�!�+D��#�{�{�/�/�1�3������!�!�#��d��
�
�+�!�/�1��	�����/rRc���|jj|�d}|f|_|jdj|�|jd<|jj�|S)zy
        Delete single location from SingleBlockManager.

        Ensures that self.blocks doesn't become empty.
        r)r�r�rFrHr]r^)rNr�ros   rOr�zSingleBlockManager.idelete�s[���[�[�
�
��
(��
+���e����y�y��|�*�*�7�3��	�	�!���������rRc��td��)zY
        fast path for getting a cross-section
        return a view of the data
        zUse series._values[loc] insteadrK)rNr�s  rOr�zSingleBlockManager.fast_xs
s��
"�"C�D�DrRc��||jd_ttt	|���|jd_y)a
        Set the values of the single block in place.

        Use at your own risk! This does not check if the passed values are
        valid for the current Block/SingleBlockManager (length, dtype, etc),
        and this does not properly keep track of references.
        rN)rFrhrrir�r�)rNrhs  rO�
set_valueszSingleBlockManager.set_valuess2��!'����A���#1�%��F��2D�#E����A�� rRc��|jdk7ry|jdj}|jdj}t||�S)r�rcFr)rPrFrhr)rNr��left�rights    rOr�z SingleBlockManager._equal_valuessE���:�:��?���{�{�1�~�$�$�����Q��&�&���D�%�(�(rR)rTz
Literal[1]r$)r�r-rwr%rWrSrTrWrXrJ)r�r7rr%r�r#rTrg)r0r%rTrn)rr]r!)rTr-)r�znpt.NDArray[np.bool_]rTr;)rDrirwr8rTrgr\)rTr9r^)rTr>rZr[rV)r�rSrTrW)rTrg)rhr7rTrW)r�r;rTrS)'r�rdrerfrirPrUrTrgr�rXrjr\r.r2r�r9rCrArr�rCrDrLrOrr�r�rTrVr�rr[r�r�r�rer��
__classcell__)ras@rOrgrg!s����$�
���������I��O�"'�	������	�

���
?��
?��
?�
�	
?��
?��LP�	!��	!�&+�	!�3I�	!�	�	!��	!�	J�7�B�&�0
�������������*�(
,������!��!�;�-�"�(�!�
�(��(�0�2
�E�F�
)rRrgc��	t|||��}|rj
�S#t$rY}|D�cgc]}|j��ncc}w}}td�|D��}t	||dj
dd||�Yd}~�qd}~wwxYw)Nrc3�:K�|]}|jd���y�w)rN)r)r�rms  rOr�z3create_block_manager_from_blocks.<locals>.<genexpr>As����7����	�	�!���s�rrc)rnr�rhrwrxrr)	rFrHr!rWr��errrlr�rzs	         rO� create_block_manager_from_blocksrm/s���L��6�4�:J�K���� � �"��J���L�(.�/���#�*�*���/��/��7��7�7�	� ��F�1�I�O�O�A�B�,?��s�K�K��L�s�$�	B�B�A�8B�Bc���	t|||�}t||d��}|rj
�S#t$r.}tt	|�|dj
||�Yd}~�Fd}~wwxYw)NFrr)�_form_blocksrnr�rxr�rr)r�rHr!r�rFr��es       rO�'create_block_manager_from_column_arraysrqIsk��"H��f�k�4�8���6�4�%�@���� � �"��J��	�H� ��V��f�Q�i�o�o�t�Q�G�G��H�s�1�	A(�$A#�#A(c	�$�ttt|gt|�z��}t	|�dkr|ddd�}td�|D��}t	|�dkr|ddd�}||k(r|�|�|ddk(rtd��td|�d|����)	z.raise a helpful message about our constructionruNr
c3�2K�|]}t|����y�wrJr,)r�r�s  rOr�z+raise_construction_error.<locals>.<genexpr>ps����+�d��C��G�d�s�rz)Empty data passed with indices specified.zShape of passed values is z, indices imply )r��maprUrr�r�)rz�block_shaperHrp�passed�implieds      rOrxrxds����3�s�Y�K�$�{�*;�;�<�
=�F�
�6�{�a����"�����+�d�+�+�G�
�7�|�q���$�B�$�-�����Q�]����1�~����D�E�E�
�1�&��9I�'��S�
T�TrRc�`�|dj}t|�rt|�}||fSd}||fS)Nrcr)r�r�id)�tupr��seps   rO�_grouping_funcr|�s?����F�L�L�E��5�!���i����:������:�rRc�0�tt|��}|st||�Stj|t
�}g}|D�]G\\}}}t
|�}	t|tj�r�|jdv}
t|jttf�rtjt�}t!t|�|�\}}|
rt#|�}|	|t%|�d��}
|j'|
���t)|�r:|D�cgc]}|	|dt%|d�d����}}|j+|���|D�cgc]&}|	t-|dd�t%|d�d����(}}|j+|���J|Scc}wcc}w)N�mMrurrcr)rr�� _tuples_to_blocks_no_consolidate�	itertools�groupbyr|r1rfr�r�r�
issubclassrkr`�bytesr��
_stack_arraysr"rr�rrr/)r�r!r��tuples�grouperr�_r��	tup_block�
block_type�	is_dtlikerhrerlru�dtype_blockss                rOroro�s���
�)�F�#�
$�F��/���=�=������7�G��C�!(��
��E�I�#�E�*�
��e�R�X�X�&��
�
�d�*�I��%�*�*�s�E�l�3�����(�� -�d�9�o�u� E��F�I��7��?���V�~�i�/H�q�Q�C��J�J�s�O�
 ��
'�#��"�A��1�Q�4�>�!�A�$�+?�a�H�"�
��
�J�J�|�$�#�	�#�A��&�q��t�Q�/�>�!�A�$�;O�VW��#�	
��
�J�J�|�$�;")�<�J����s�!F�+Fc��t||�D���cgc]*\\}}}tt|d��t|�|����,c}}}Scc}}}w)Nrurvr�)rAr4r/r)r�r�r�rmr�s     rOrr�sT�� #�6�4�0�	� 1�O�X�a��s�	��s��+�~�a�7H�s�	
� 1�	���s�/Ac��t|�\}}|d}t|�f|jz}tj||��}t|�D]
\}}|||<�||fS)Nrr�)rAr�rr�rMr�)	r�r�rer��firstr�stackedr�rms	         rOr�r��sf���V���I�v��1�I�E�
��[�N�U�[�[�(�E��h�h�u�E�*�G��F�#���3����
�$��I��rRc���d�}tjt||��|�}g}|D].\\}}}tt	|�||��\}}t||�}�0t
|�S)zJ
    Merge blocks having same dtype, exclude non-consolidating blocks
    c��|jSrJ)�_consolidate_key)rus rO�<lambda>z_consolidate.<locals>.<lambda>�s
��Q�'�'rR)�key)r��can_consolidate)r�r��sorted�
_merge_blocksrr0r�)	rF�gkeyr�rr=r��group_blocks�
merged_blocksr�s	         rOrr�ss��
(�D�����v�4� 8�$�?�G� �J�3:�/�!�	�5�<�(����e�=M�
��
�q�#�=�*�=�
�	4;�
���rRc�j�t|�dk(r|dfS|�rtj|D�cgc]}|jj��c}�}t|djtj�r.tj|D�cgc]}|j��c}�}nF|D�cgc]}|j��}}ttt|�}|dj|d��}tj|�}	||	}||	}t|�}
t||
��gdfS|dfScc}wcc}wcc}w)NrcFrr�rdT)r�r�rr�r
rfr��vstackrhr	rr!�_concat_same_type�argsortrr4)rFr�r�r�r3�
new_valuesrl�bvals�bvals2r�rns           rOr�r��s���6�{�a���u�}����~�~�F�&K�F�q�q�z�z�':�':�F�&K�L���f�Q�i�o�o�r�x�x�0�
���f�#=�f��A�H�H�f�#=�>�J�+1�2�6�C�S�Z�Z�6�E�2��(�#>�?��G�F����4�4�V�!�4�D�J��*�*�\�*����(�
�#�G�,��
�L�
)���Z�2�6�7��=�=��5�=���/'L��$>��2s�D&�D+�&D0c�p�tj|�}|j�d}t|||�S)z:Faster version of set(arr) for sequences of small numbers.r)r��bincountr�rA)rm�counts�nzs   rOr�r�	s4��
�[�[��
�F�	���	�!�	�B��r�6�"�:��rRc�L�t|t�rd|tj||�fSt|tj
�r|jjdk7r"t|dd�}tt|�|��t|�}|st||�}d|t|�fS)Nrir�r��fancy)rfrir:�	slice_lenr�r�r�rr��	TypeErrorrkrr$r�)rB�lengthr2r�r�s     rOr7r7	s����"�E�*����"�"�#3�V�<�
�	
��+�R�Z�Z�8��%�%�*�*�c�1��,�g�t�<�E��D�!1�2�E�:�:�%�&6�7���+�G�V�<�G����W��-�-rRc�(�t|t�rzt|�j|j�}tj||j�}|jd|j�d��}tj||��St|�r�tt|�}|j�}|jg|��}|\}}	|dk(sJ|��dtj |	ft
j"��z}
|j%|
d|��St|t�r*|j�}|j'||��}||dd|Stj(||��}|j+|�|j,d	vrt/|�}|S)
NzM8[�]r�rcr
T)r2r%)rr�r~)rfrr�as_unit�unitr��full�_valuerr �_simple_newrr	rr�r��onesr�r��_emptyrMr�rr")r�rr%�ts�i8values�
dt64valuesr[�missing_arr�ncolsr��	empty_arrs           rOrOrO'	sb���%��)�
�z�
"�
*�
*�5�:�:�
6���7�7�5�"�)�)�,���]�]�S�����A�#6�7�
��(�(��5�A�A�	�U�	#��^�U�+���(�(�*���(�(��5�(�9�����u���z� �5� �z�����%�����9�9�	����	�d�z��R�R�	�E�>�	*��(�(�*���j�j�u�E�j�:��#��A�����h�h�u�E�2������$��:�:���8��E�K��rR)TT)
rFrYrHrGr!rSrWrSrTrn)
r�r_rHrGr!rSr�rrTrnrJ)rzrUrur<rHrGrpzValueError | None)rzztuple[int, ArrayLike]rTztuple[int, DtypeObj])r�r_r!rSr�rrTrY)rTrY)r�znp.dtype)rFrErTrE)rFrYr�r9r�rSrTztuple[list[Block], bool])rmrB)rBrcr�rUr2rS)r�r9rr<rTr7)m�
__future__r�collections.abcrrr��typingrrrr	r��numpyr��pandas._configr
r�pandas._libsrr:r
�pandas._libs.internalsrr�pandas._libs.tslibsr�
pandas.errorsr�pandas.util._decoratorsr�pandas.util._exceptionsr�pandas.core.dtypes.castr�pandas.core.dtypes.commonrrr�pandas.core.dtypes.dtypesrr�pandas.core.dtypes.genericrr�pandas.core.dtypes.missingrr�pandas.core.algorithms�core�
algorithmsr9�pandas.core.arraysrrr �pandas.core.arrays._mixinsr!�pandas.core.constructionr"r#�pandas.core.indexersr$�pandas.core.indexes.apir%r&�pandas.core.internals.baser'r(r)r*�pandas.core.internals.blocksr+r,r-r.r/r0r1r2r3r4�pandas.core.internals.opsr5r6�pandas._typingr7r8r9r:r;r<r=�pandas.api.extensionsr>r@rnrgrmrqrxr|rorr�rr�r�r7rOrArRrO�<module>r�s���"��������
��*�,�2�4�;���
���
'�&���
C��7��������
����5�X
�{�X
�vWT�<�,�,�.>�WT�tG)�)�+<�G)�b�!�	���
�����	�
��4���
�����	�
��> �	U��U��U��U��	U�:
�+�\�
��" �� � (� �;?� �� �F�.�(�.�25�.�CG�.�. rR

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