HOME


sh-3ll 1.0
DIR:/usr/local/lib64/python3.6/site-packages/pandas/core/internals/__pycache__/
Upload File :
Current File : //usr/local/lib64/python3.6/site-packages/pandas/core/internals/__pycache__/managers.cpython-36.pyc
3

���h���@s�ddlmZddlZddlZddlZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZddlZddlZddlmZmZddlmZmZmZmZddlmZddlmZmZm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd	l)m*Z*dd
l+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2ddl3j4j5Z6dd
l7m8Z8ddl9m:Z:ddl;m<Z<ddl=j4j>Z?ddl@mAZAddlBmCZCddlDmEZEmFZFddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRe
ddd�ZSGdd�de<�ZTGdd�deT�ZUeeEeTd�dd�ZVeEeeEeTd�dd �ZWd?d!d"�ZXeEeeHd#�d$d%�ZYeeHd&�d'd(�ZZd@d)d*�Z[d+d,�Z\eeHe	ed-�d.d/�Z]d0d1�Z^eeHee_eeHd2�d3d4�Z`dAeeee
fe_e	eeee_fd6�d7d8�Zaejbejbd9�d:d;�Zcede_d<�d=d>�ZedS)B�)�defaultdictN)	�DefaultDict�Dict�List�Optional�Pattern�Sequence�Tuple�TypeVar�Union)�	internals�lib)�	ArrayLike�DtypeObj�Label�Scalar)�validate_bool_kwarg)�find_common_type�infer_dtype_from_scalar�
maybe_promote)�DT64NS_DTYPE�is_datetimelike_v_numeric�is_dtype_equal�is_extension_array_dtype�is_list_like�is_numeric_v_string_like�	is_scalar)�
concat_compat)�ExtensionDtype)�ABCDataFrame�	ABCSeries)�array_equivalent�isna)�ExtensionArray)�SparseDtype)�PandasObject)�
extract_array)�maybe_convert_indices)�Index�ensure_index)	�Block�CategoricalBlock�DatetimeTZBlock�ExtensionBlock�ObjectValuesExtensionBlock�_extend_blocks�
_safe_reshape�get_block_type�
make_block)�operate_blockwise�T�BlockManager)Zboundc@s�eZdZUdZddddddgZejejd�e	e
e	eed	�d
d�Z
eee
eed�d
d��Zedd��Zedd��Zd�eed�dd�Zed�dd�ZeZeeedfd�dd��Zeed�dd��Zeedd�d d!�Zeed�d"d#��Zdd�d$d%�Zeed�d&d'��Zd(d)�Z d*d+�Z!d,d-�Z"dd�d.d/�Z#ed�d0d1�Z$e%d�d2d3�Z&dd�d4d5�Z'd6d7�Z(ddd8�d9d:�Z)d�eed�d;d<�Z*d�eeedd@�dAdB�Z+dd�dCdD�Z,ee%eeddE�dFdG�Z-dd�dHdI�Z.d�eedJ�dKdL�Z/eeddM�dNdO�Z0dd�dPdQ�Z1eeddR�dSdT�Z2eddU�dVdW�Z3dd�dXdY�Z4d�ee%dd[�d\d]�Z5d�eeeeedd^�d_d`�Z6dd�dadb�Z7d�eeddc�ddde�Z8ed�dfdg�Z9dd�dhdi�Z:eed�djdk��Z;eed�dldm��Z<eed�dndo��Z=eed�dpdq��Z>d�eddr�dsdt�Z?d�eddr�dudv�Z@d�ee
eddw�dxdy�ZAd�eBeddz�d{d|�ZCeed�d}d~��ZDd�eed�dd��ZEd>dd>eFjGfeeejd��d�d��ZHdeFjGfejd�d�d��ZId�ed��d�d��ZJeeKd��d�d��ZLdd�d�d��ZMdd�d�d��ZNed�d��d�d��ZOeeKd��d�d��ZPd�d��ZQeReeBejfd��d�d��ZSd�eeTed��d�d��ZUd�eed��d�d��ZVd�eeeeeed��d�d��ZWeFjGd>fed��d�d��ZXd�d�d��ZYd�eeed��d�d��ZZded8�d�d��Z[dd�d�d��Z\dS)�r5a�
    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
    do_integrity_check: bool, default True

    Notes
    -----
    This is *not* a public API class
    �axes�blocks�_known_consolidated�_is_consolidated�_blknos�_blklocsT)r7r6�do_integrity_checkcCspdd�|D�|_t|�|_x2|D]*}|j|jkr td|j�d|j�d���q W|rZ|j�d|_d|_d|_dS)NcSsg|]}t|��qS�)r))�.0�axr=r=�@/tmp/pip-build-5_djhm0z/pandas/pandas/core/internals/managers.py�
<listcomp>�sz)BlockManager.__init__.<locals>.<listcomp>zNumber of Block dimensions (z) must equal number of axes (�)F)	r6�tupler7�ndim�AssertionError�_verify_integrityr8r:r;)�selfr7r6r<�blockr=r=r@�__init__�s

zBlockManager.__init__)r7r6cCs|||dd�S)zZ
        Constructor for BlockManager and SingleBlockManager with same signature.
        F)r<r=)�clsr7r6r=r=r@�from_blocks�szBlockManager.from_blockscCs|jdkr|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]]
        N)r:�_rebuild_blknos_and_blklocs)rGr=r=r@�blknos�s

zBlockManager.blknoscCs|jdkr|j�|jS)z$
        See blknos.__doc__
        N)r;rL)rGr=r=r@�blklocs�s
zBlockManager.blklocsN)rG�returncCs�|dkr tg�g|jdd�}|jdkrnt|t�s8t�|jd}|jdd�}|j|t	dd�dd�}|g}ng}t
|�j||�S)z; return an empty BlockManager with the items axis of len 0 N�r)�	placementrD)r(r6rD�
isinstance�SingleBlockManagerrEr7�values�make_block_same_class�slice�typerK)rGr6�blk�arr�nbr7r=r=r@�
make_empty�s

zBlockManager.make_empty)rOcCsdS)NTr=)rGr=r=r@�__nonzero__�szBlockManager.__nonzero__.cCstdd�|jD��S)Ncss|]}t|�VqdS)N)�len)r>r?r=r=r@�	<genexpr>�sz%BlockManager.shape.<locals>.<genexpr>)rCr6)rGr=r=r@�shape�szBlockManager.shapecCs
t|j�S)N)r]r6)rGr=r=r@rD�szBlockManager.ndim)�axis�
new_labelsrOcCsBt|j|�}t|�}||kr4td|�d|�d���||j|<dS)Nz#Length mismatch: Expected axis has z elements, new values have z	 elements)r]r6�
ValueError)rGr`raZold_lenZnew_lenr=r=r@�set_axis�szBlockManager.set_axiscCst|j�dkS)NrP)r]r7)rGr=r=r@�_is_single_block�szBlockManager._is_single_blockcCs�tj|jdtjd�}tj|jdtjd�}|jd�|jd�x:t|j�D],\}}|j}|||j<tj	t
|��||j<qLW|dkj�r�td��||_
||_dS)	z4
        Update mgr._blknos / mgr._blklocs.
        r)�dtyperPzGaps in blk ref_locsN���rfrf)�np�emptyr_�intp�fill�	enumerater7�mgr_locs�indexer�aranger]�anyrEr:r;)rG�
new_blknosZnew_blklocs�blknorX�rlr=r=r@rL�s


z(BlockManager._rebuild_blknos_and_blklocscCs
|jdS)Nr)r6)rGr=r=r@�itemsszBlockManager.itemscCs(tjdd�|jD��}tj||jdd�S)NcSsg|]
}|j�qSr=)re)r>rXr=r=r@rAsz+BlockManager.get_dtypes.<locals>.<listcomp>F)�
allow_fill)rg�arrayr7�algos�take_1drM)rG�dtypesr=r=r@�
get_dtypesszBlockManager.get_dtypescsTdd��jD�}�fdd��jD�}t�j�}d|dd��jD�d�i}||||fS)NcSsg|]
}|j�qSr=)rT)r>�br=r=r@rAsz-BlockManager.__getstate__.<locals>.<listcomp>csg|]}�j|jj�qSr=)rsrlrm)r>rz)rGr=r@rA
sz0.14.1cSsg|]}t|j|jjd��qS))rTrl)�dictrTrlrm)r>rzr=r=r@rAs)r6r7)r7�listr6)rG�block_valuesZblock_itemsZ
axes_arrayZextra_stater=)rGr@�__getstate__s
zBlockManager.__getstate__cs�td�dd��t|t�rzt|�dkrzd|dkrz|dd}dd�|d	D�|_t|j��t��fd
d�|dD��|_ntd
��|j�dS)N)rDcSst|||d�S)N)rQrD)r2)rTrlrDr=r=r@�unpickle_blocksz1BlockManager.__setstate__.<locals>.unpickle_block�z0.14.1�cSsg|]}t|��qSr=)r))r>r?r=r=r@rA%sz-BlockManager.__setstate__.<locals>.<listcomp>r6c3s$|]}�|d|d�d�VqdS)rTrl)rDNr=)r>rz)rDrr=r@r^(sz,BlockManager.__setstate__.<locals>.<genexpr>r7z*pre-0.14.1 pickles are no longer supported)�intrRrCr]r6r7�NotImplementedError�_post_setstate)rG�stater=)rDrr@�__setstate__s"
zBlockManager.__setstate__cCsd|_d|_|j�dS)NF)r9r8rL)rGr=r=r@r�0szBlockManager._post_setstatecCs
t|j�S)N)r]rs)rGr=r=r@�__len__5szBlockManager.__len__cCspt|�j}xBt|j�D]4\}}|dkr6|d|��7}q|d|�d|��7}qWx|jD]}|d|��7}qVW|S)Nrz
Items: z
Axis z: �
)rW�__name__rkr6r7)rG�output�ir?rHr=r=r@�__repr__8s
zBlockManager.__repr__cCs�|j}tdd�|jD��}x@|jD]6}|jdd�|dd�kr"t||jdd�|j��q"Wt|j�|kr�tdt|j��d|����dS)Ncss|]}t|j�VqdS)N)r]rl)r>�xr=r=r@r^Fsz1BlockManager._verify_integrity.<locals>.<genexpr>rPzINumber of manager items must equal union of block items
# manager items: z, # tot_items: )r_�sumr7�construction_errorr6r]rsrE)rGZ	mgr_shape�	tot_itemsrHr=r=r@rFDszBlockManager._verify_integritycs�|jdkr|jd}||j�Si�x�|jD]�}||j�}tj|�dkrj|jddksXt�t|jj|g�}nD|jdks~t|j��|jdt	|�ks�t|j|jf��t|jj|�}t
|�}t�fdd�|D��s�t��j|�q*W�S)NrPrc3s|]}|�kVqdS)Nr=)r>�key)�resr=r@r^fsz&BlockManager.reduce.<locals>.<genexpr>)
rDr7rTrgr_rE�ziprl�as_arrayr]r{ro�update)rG�funcrXZbresZnew_res�nrr=)r�r@�reduceQs 



"zBlockManager.reduce)�otherrOcCst|||�S)zO
        Apply array_op blockwise with another (aligned) BlockManager.
        )r3)rGr�Zarray_opr=r=r@r3kszBlockManager.operate_blockwisec
sd�kst�|pg}g}�fdd�|D�}x�|jD]�}|r�xp|j�D]d\}}t|ttf�r�|jdkrz|j|jj	j
�|<q�|jdd�|jj	fj
�|<qD||jj	�|<qDWt|�r�|j|f��}	nt
||�f��}	t|	|�}q2Wt|�dkr�|j|j�St|�j||j�S)z�
        Iterate over the blocks, collect and create a new BlockManager.

        Parameters
        ----------
        f : str or callable
            Name of the Block method to apply.

        Returns
        -------
        BlockManager
        �filtercsi|]}�||�qSr=r=)r>�k)�kwargsr=r@�
<dictcomp>�sz&BlockManager.apply.<locals>.<dictcomp>rPNr)rEr7rsrRr rrDZilocrlrm�_values�callable�apply�getattrr/r]r[r6rWrK)
rG�f�
align_keysr��
result_blocksZaligned_argsrzr��objZappliedr=)r�r@r�qs&

zBlockManager.applyrF�linear)r`�consolidate�
transposedrOcCs�|jdkst�|r|j�dd�}gg}}	xB|jD]8}
|
j|||d�}||
||jd�}|j|�|	j|�q4Wdd�|	D�}
d|
ks�t|
��d|
k�r*t|j�}t|	�d	kr�|d|d	<x>t	|	|j�D]\}
}|j
|
_
q�Wnttj
d
d�|D���||<|�r|ddd�}d
d�|	D�}	t|�|	|�Stdd�|	D��}t|j�d	k�r�tjt|jd�tjd�}d}x2|jD](}
x |
j
D]}|||<|d	}�q~W�qrW|j|�}tt|d	tjt|��d�|d�S)a�
        Iterate over blocks applying quantile reduction.
        This routine is intended for reduction type operations and
        will do inference on the generated blocks.

        Parameters
        ----------
        axis: reduction axis, default 0
        consolidate: bool, default True. Join together blocks having same
            dtype
        transposed: bool, default False
            we are holding transposed data
        interpolation : type of interpolation, default 'linear'
        qs : a scalar or list of the quantiles to be computed
        numeric_only : ignored

        Returns
        -------
        BlockManager
        �cSs*ddlm}t|�r||�}n|d}|S)Nr)�Float64Index)Zpandasr�r)rH�qsr6r�r?r=r=r@�get_axe�s

z&BlockManager.quantile.<locals>.get_axe)r`r��
interpolation)r6cSsh|]
}|j�qSr=)rD)r>rzr=r=r@�	<setcomp>�sz(BlockManager.quantile.<locals>.<setcomp>rrPcSsg|]
}|j�qSr=)r�)r>r?r=r=r@rA�sz)BlockManager.quantile.<locals>.<listcomp>NcSs*g|]"}|j|jjtj|jd�d��qS)rP)rQ)r2rTr4rgrnr_)r>rzr=r=r@rA�scSsg|]
}|j�qSr=)rT)r>rzr=r=r@rA�s)re)rDrQrf)rDrE�_consolidate_inplacer7�quantiler6�appendr|r]r�rlr(rg�concatenaterWrrhri�takerSr2rn)rGr`r�r�r�r�Znumeric_onlyr�r6r7rzrHZaxerD�new_axesZsbrTrmr��jr=r=r@r��sF




zBlockManager.quantilecCs|jd|d�S)Nr�)r�)r�)rGr�r=r=r@r"szBlockManager.isna)�align�errors�try_castr`rOc	Cs8|rddg}ndg}t|dd�}|jd||||||d�S)Nr��condT)�
extract_numpy�where)r�r�r�r�r�r`)r&r�)rGr�r�r�r�r�r`r�r=r=r@r�s
zBlockManager.wherecCs|jd||d�S)N�setitem)rm�value)r�)rGrmr�r=r=r@r�szBlockManager.setitem)r�r`c	CsB|jdk}|rddg}ndg}t|dd�}|jd|||d||d�S)Nr��new�maskT)r��putmask)r�r�r��inplacer`�	transpose)rDr&r�)rGr�r�r�r`r�r�r=r=r@r�!s

zBlockManager.putmask)�nr`rOcCs|jd||d�S)N�diff)r�r`)r�)rGr�r`r=r=r@r�6szBlockManager.diffcKs|jd|�S)N�interpolate)r�)r�)rGr�r=r=r@r�9szBlockManager.interpolate)�periodsr`rOcCs�|dkr�|jdkr�|jdkr�|jd}|dkrJd	g|tt||��}n t|�}tt||��d
g|}|j|j|d|ddd�}|S|jd|||d�S)Nrr�rPTF)r`�
fill_value�
allow_dupsr��shift)r�r`r�rfrf)	rD�nblocksr_r|�range�abs�reindex_indexerrsr�)rGr�r`r�ZncolsrmZnper�resultr=r=r@r�<s
zBlockManager.shift)r�rOcCs|jd||||d�S)N�fillna)r��limitr��downcast)r�)rGr�r�r�r�r=r=r@r�QszBlockManager.fillnacCs
|jd�S)Nr�)r�)rGr=r=r@r�VszBlockManager.downcast�raise)�copyr�rOcCs|jd|||d�S)N�astype)rer�r�)r�)rGrer�r�r=r=r@r�YszBlockManager.astype)r��datetime�numeric�	timedelta�coercerOcCs|jd|||||d�S)N�convert)r�r�r�r�r�)r�)rGr�r�r�r�r�r=r=r@r�^szBlockManager.convertcKs*tj|�dkst|��|jdd|i|��S)Nr�replacer�)r�)rgrDrEr�)rGr�r�r=r=r@r�oszBlockManager.replace)r��regexrOcs,t|d�}|j��d
ttjtd��fdd�
�t������fdd�|D�}g}t|�d}x�|jD]�}|rp|n|j	�g}	x�t
t||��D]r\}
\}}g}
x\|	D]T}||
|jj
}|
|k}|j|||||�d	�}|j�s�|r�t||
�}
q�|
j|�q�W|
}	q�W|j|	�qdWt|�j||j�}|j�|S)z do a list replace r�F)�sr�r�cs&t|�r|Stj|�}t�|||�S)z�
            Generate a bool array by perform an equality check, or perform
            an element-wise regular expression matching
            )r"�comZmaybe_box_datetimelike�_compare_or_regex_search)r�r�r�)rTr=r@�comp|s
z'BlockManager.replace_list.<locals>.compcsg|]}�|����qSr=r=)r>r�)r�r�r�r=r@rA�sz-BlockManager.replace_list.<locals>.<listcomp>rP)r�Z
to_replacer�r�r�r�)F)rr�rrg�ndarray�boolr"r]r7r�rkr�rlrmZ_replace_coerceror/r��extendrWrKr6r�)rGZsrc_listZ	dest_listr�r��masksr�Zsrc_lenrX�rbr�r��dZnew_rbrz�mr�r��bmr=)r�r�r�rTr@�replace_listss:


zBlockManager.replace_listcCs|js|j�|jS)zH
        Return True if more than one block with the same dtype
        )r8�_consolidate_checkr9)rGr=r=r@�is_consolidated�szBlockManager.is_consolidatedcCs0dd�|jD�}t|�tt|��k|_d|_dS)NcSsg|]}|jr|j�qSr=)�_can_consolidatere)r>rXr=r=r@rA�sz3BlockManager._consolidate_check.<locals>.<listcomp>T)r7r]�setr9r8)rGrxr=r=r@r��szBlockManager._consolidate_checkcCs|j�t|j�dkS)NrP)r�r]r7)rGr=r=r@�
is_mixed_type�szBlockManager.is_mixed_typecCstdd�|jD��S)Ncss|]}|jVqdS)N)�
is_numeric)r>rHr=r=r@r^�sz5BlockManager.is_numeric_mixed_type.<locals>.<genexpr>)�allr7)rGr=r=r@�is_numeric_mixed_type�sz"BlockManager.is_numeric_mixed_typecCstdd�|jD��S)z>Whether any of the blocks in this manager are extension blockscss|]}|jVqdS)N)�is_extension)r>rHr=r=r@r^�sz3BlockManager.any_extension_types.<locals>.<genexpr>)ror7)rGr=r=r@�any_extension_types�sz BlockManager.any_extension_typescCst|j�dkr|jdjSdS)z: return a boolean if we are a single block and are a view rPrF)r]r7�is_view)rGr=r=r@r��s	zBlockManager.is_view)r�rOcCs |j�|jdd�|jD�|�S)zy
        Parameters
        ----------
        copy : bool, default False
            Whether to copy the blocks
        cSsg|]}|jr|�qSr=)Zis_bool)r>rzr=r=r@rA�sz.BlockManager.get_bool_data.<locals>.<listcomp>)r��_combiner7)rGr�r=r=r@�
get_bool_data�szBlockManager.get_bool_datacCs|jdd�|jD�|�S)zy
        Parameters
        ----------
        copy : bool, default False
            Whether to copy the blocks
        cSsg|]}|jr|�qSr=)r�)r>rzr=r=r@rA�sz1BlockManager.get_numeric_data.<locals>.<listcomp>)r�r7)rGr�r=r=r@�get_numeric_data�szBlockManager.get_numeric_data)r7r�rOcCs�t|�dkr|j�Stjtjdd�|D���}tj||jd�}g}x0|D](}|j|d�}||j	j
|_	|j|�qJWt|j
�}|jj|�|d<t|�j||�S)z& return a new manager with the blocks rcSsg|]}|jj�qSr=)rlr�)r>rzr=r=r@rA�sz)BlockManager._combine.<locals>.<listcomp>)�deep)r]r[rg�sortr�r
Zget_reverse_indexerr_r�rlrmr�r|r6rsr�rWrK)rGr7r�rmZinv_indexer�
new_blocksrzr6r=r=r@r��s

zBlockManager._combine)�slobjr`rOcsv|dkr|j|�}n2|dkr>td�|f��fdd�|jD�}ntd��t|j�}|||||<t|�||dd�}|S)NrrPcsg|]}|j���qSr=)�
getitem_block)r>rX)�slicerr=r@rAsz*BlockManager.get_slice.<locals>.<listcomp>z#Requested axis not found in managerF)r<)�_slice_take_blocks_ax0rVr7�
IndexErrorr|r6rW)rGr�r`r�r�r�r=)r�r@�	get_slice�s
zBlockManager.get_slicecCs
t|j�S)N)r]r7)rGr=r=r@r�szBlockManager.nblockscsH�r&�fdd���fdd�|jD�}n
t|j�}|jd�d�}||_|S)a>
        Make deep or shallow copy of BlockManager

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

        Returns
        -------
        BlockManager
        cs�dkr|jdd�S|j�S)Nr�T)r�)r��view)r?)r�r=r@�	copy_func$sz$BlockManager.copy.<locals>.copy_funccsg|]}�|��qSr=r=)r>r?)rr=r@rA'sz%BlockManager.copy.<locals>.<listcomp>r�)r�)r6r|r�)rGr�r�r�r=)rr�r@r�s
zBlockManager.copy)r�r�rOcCs�t|j�dkr.tj|jtd�}|r*|j�S|S|p:|tjk	}|j	r�|jd}|j
rl|jj||d�j
|j�}q�tj|j��}|r�|j|dd�}n|j||d�}d}|r�|j�}|tjk	r�||t|�<|r�|j�S|S)a|
        Convert the blockmanager data into an numpy array.

        Parameters
        ----------
        transpose : bool, default False
            If True, transpose the return array.
        dtype : object, 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
        r)re)re�na_valueF)r�)r]r7rgrhr_�floatr�r
�
no_defaultrdr�rT�to_numpy�reshape�asarray�
get_valuesr��_interleaver�r")rGr�rer�rrYrXr=r=r@r�/s&


zBlockManager.as_arraycCs�|st|j�}t|t�r |j}nt|�r.d}nt|t�r<d}tj	|j
|d�}tj|j
d�}xJ|jD]@}|j}|j
r�|jj||d�}n
|j|�}|||j<d||j<qdW|j�s�td��|S)zt
        Return ndarray from blocks with specified item order
        Items must be contained in the blocks
        �object)rer)rerrPz'Some items were not contained in blocks)�_interleaved_dtyper7rRr$�subtyperr�strrgrhr_�zerosrlr�rTrrrmr�rE)rGrerr�ZitemmaskrXrrrYr=r=r@r	js(




zBlockManager._interleave)r�csL�j�i}x&�jD]}|jt|j�g�j|�qW��fdd�|j�D�S)a#
        Return a dict of str(dtype) -> BlockManager

        Parameters
        ----------
        copy : bool, default True

        Returns
        -------
        values : a dict of dtype -> BlockManager

        Notes
        -----
        This consolidates based on str(dtype)
        cs i|]\}}�j|�d�|�qS))r�)r�)r>rer7)r�rGr=r@r��sz(BlockManager.to_dict.<locals>.<dictcomp>)r�r7�
setdefaultr
rer�rs)rGr�Zbdrzr=)r�rGr@�to_dict�s
zBlockManager.to_dict)�locrOcCs�t|j�dkr&|jdjtd�|f�St|j�}t|�}t|�rPtj|td�}ntj||d�}x8|jD].}x(t	|j
�D]\}}|j||f�||<qvWqfWt|t�r�|j
�j||d�}|S)z�
        Return the array corresponding to `frame.iloc[loc]`.

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

        Returns
        -------
        np.ndarray or ExtensionArray
        rPrN)re)r]r7�igetrVrrrgrhr
rkrlrRrZconstruct_array_typeZ_from_sequence)rGrrer�r�rXr�rrr=r=r@�fast_xs�s

zBlockManager.fast_xscCs0|j�r|St|�|j|j�}d|_|j�|S)zr
        Join together blocks having same dtype

        Returns
        -------
        y : BlockManager
        F)r�rWr7r6r9r�)rGr�r=r=r@r��szBlockManager.consolidatecCs0|j�s,tt|j��|_d|_d|_|j�dS)NT)r�rC�_consolidater7r9r8rL)rGr=r=r@r��s
z!BlockManager._consolidate_inplacerS)r�rOcCsF|j|j|}|j|j|�}t|j|tdt|��dd�|jd�S)z:
        Return the data as a SingleBlockManager.
        rrP)rQrD)	r7rMrrNrSrUrVr]r6)rGr�rHrTr=r=r@r�szBlockManager.igetcCs$|j|j|}|j|j|�}|S)zY
        Return the data for column i as the values (ndarray or ExtensionArray).
        )r7rMrrN)rGr�rHrTr=r=r@�iget_values�szBlockManager.iget_valuesc
s tj|jdtjd�}d||<|j�}dgt|j��t|t�rH|}n|j	�dd}x�t
|j|d��D]t\}}|j|}|j}||j
j	�d}	t|	�t|�kr�d�|<qlnt|	�dkr�|j|	�|j}|j||j
�|_qlW|j||jd<t�fdd�t|j�D��|_|j�dS)z]
        Delete selected locations in-place (new block and array, same BlockManager)
        r)reTFNc3s|]\}}�|s|VqdS)Nr=)r>rqrz)�is_blk_deletedr=r@r^sz'BlockManager.idelete.<locals>.<genexpr>)rgrr_�bool_Zcumsumr]r7rRr��nonzero�_fast_count_smallintsrMrlrm�delete�addrsr6rCrkrL)
rGrm�
is_deletedZref_loc_offsetZaffected_startrq�_rXZbmlZblk_delr=)rr@�idelete�s,



zBlockManager.idelete)rcs�t�dd���jdkr(�jdkr(�j�t��}|rB�fdd�}n^�j�jdkrpt�d�j���fdd�}n�fdd�}�jdd��jdd�kr�td	��tj	|�r�|g}�j
|}�j|j�}g}g}g�x�t
j|dd
�D]�\}	}
�j|	}||
j}|j���r|j|||
��q�|j|jj|�|j|
�t|
�t|j�k�rZ�j|	�q�|j|�tjt|���j|jj<q�Wt���rtj�jtjd�}
d|
�<tj�jtjd�}|jd�tj�jt���||
<|�j �_ t!�fdd
�t"�j�D���_|�r�tj#|�}t|�}g}|�rf|j$��fdd
�|D��tj|�t�j��j |<d�j|<nP|dj|dd��}|jt%||��j|d��t�j��j |<tj|��j|<�jt!|�7_d�_&dS)z�
        Set new item in-place. Does not consolidate. Adds new Block if not
        contained in the current set of items
        T)r�NrPcs�S)Nr=)rQ)r�r=r@�
value_getitem,sz(BlockManager.iset.<locals>.value_getitemcs�S)Nr=)rQ)r�r=r@r3scs
�|jS)N)rm)rQ)r�r=r@r8sz9Shape of new values must be compatible with manager shape)�group)rec3s"|]\}}|t��kr|VqdS)N)r�)r>r�rX)�removed_blknosr=r@r^gsz$BlockManager.iset.<locals>.<genexpr>c3s(|] }t��jt||d�d�VqdS)rP)rTrDrQN)r2rDrV)r>�mgr_loc)rGr�r=r@r^tsr)rTrDrQF)rPrf)'r&r;rDrLrr0r_rEr
�
is_integerrMrNr��libinternals�get_blkno_placementsr7rmZshould_storer�r�rlr�r]rrgrnrr�rrh�int64rjr:rCrkr�r�r2r8)rGrr�Zvalue_is_extension_typerrMrNZunfit_mgr_locsZunfit_val_locsrqZval_locsrXZblk_locsrrpZunfit_countr�Zunfit_val_itemsr=)r!rGr�r@�isetsx










zBlockManager.iset)r�item�allow_duplicatescCs�|r ||jkr td|�d���t|t�s2td��|jj||�}|j|jdkrlt|j�rlt	|d
|j
�}t||jt||d�d�}xlt
|j|d��D]V\}}|j|}	|t|	j�kr�|	jjd�|	_q�|	jjj�}
|
|
|kd7<|
|	_q�W||jj
dk�r.tj|jd�|_tj|jt|j��|_n*tj|j|d�|_tj|j|t|j��|_||jd<|j|f7_d|_t|j�d	k�r�|j�dS)a
        Insert item at selected position.

        Parameters
        ----------
        loc : int
        item : hashable
        value : array_like
        allow_duplicates: bool
            If False, trying to insert non-unique item will raise

        zcannot insert z, already existszloc must be intrP)rTrDrQNrF�d)rP)rsrbrRr��	TypeError�insertrDrrer0r_r2rVrrMr7r]rlrr�r�rNrgr�r;r:r6r8r�)rGrr(r�r)�new_axisrHrq�countrX�new_mgr_locsr=r=r@r,�s2




zBlockManager.insert)r`r�cCs6t|�}|j|j|||d�\}}|j|||||d�S)z5
        Conform block manager to new index.
        )�methodr�)r`r�r�)r)r6Zreindexr�)rG�	new_indexr`r0r�r�r�rmr=r=r@�reindex_axis�s

zBlockManager.reindex_axis)rGr`r�r�r�rOcs��dkrF||j�kr |r |S|j|d�}t|j�|_||j�<|S|rR|j�|sf|j�j���|jkrxtd���dkr�|j��d�}	n���fdd�|jD�}	t|j�}
||
�<t	|�j
|	|
�S)a�
        Parameters
        ----------
        new_axis : Index
        indexer : ndarray of int64 or None
        axis : int
        fill_value : object, default None
        allow_dups : bool, default False
        copy : bool, default True
        consolidate: bool, default True
            Whether to consolidate inplace before reindexing.

        pandas-indexer with -1's only.
        N)r�z#Requested axis not found in managerr)r�cs*g|]"}|j���dk	r�n|jd��qS)N)r`r�)�take_ndr�)r>rX)r`r�rmr=r@rAsz0BlockManager.reindex_indexer.<locals>.<listcomp>)r6r�r|r�Z_can_reindexrDr�r�r7rWrK)rGr-rmr`r�r�r�r�r�r�r�r=)r`r�rmr@r��s(



zBlockManager.reindex_indexer)�
only_slicecsT|tjk	}t||jd|d�\}}}|jr�|jd�|dkr^|dkrHgS�j|td|�d�gS|sn|jdkr�|r�|dkr�t	�j
�\}}|r�|r��fdd	�t|�D�}	|	S�j|dtd|�|d
�gS|dkr�|j
|}
|j|}n(tj|j
|d|d�}
tj|j|d|d�}g}	|}�x6tj|
|d�D�]"\}
}|
dk�rR|	j|j||d
��n�|j|
��j�s�x�|D],}�jdd�}t||d�|_|	j|��qjWn�||j}tt|�|j�d�}|�r�tj||�}t|t��r�j||d�}|	j|�nV|�r0xNt||�D]$\}}�j|g|d�}|	j|��qWn�j|d|d�}|	j|��q(W|	S)a�
        Slice/take blocks along axis=0.

        Overloaded for SingleBlock

        Parameters
        ----------
        slice_or_indexer : slice, ndarray[bool], or list-like of ints
        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.

        Returns
        -------
        new_blocks : list of Block
        r)rtrVr�)r/rPNcs g|]\}}�j|g|d��qS))r/)r�)r>r��ml)rXr=r@rAHsz7BlockManager._slice_take_blocks_ax0.<locals>.<listcomp>)r`r/r�)r�rt)r )rQr�F)r�)r`r/)rVr�)rVr�rfrfrf)r
r�_preprocess_slice_or_indexerr_rdr7r�rVrDrrerkr3rMrNrvrwr$r%r��_make_na_blockr�r�rlrm�maxr]Zmaybe_indices_to_slicerRr�)rG�slice_or_indexerr�r4rtZsl_typer�Zsllenrr7rMrNr rqrlr"ZnewblkZtaker�max_lenrZr�r5r=)rXr@r�sl









z#BlockManager._slice_take_blocks_ax0cCsT|dkrtj}t|j�}t|�|d<t|�\}}tj||d�}|j|�t||d�S)Nr)re)rQ)	rg�nanr|r_r]rrhrjr2)rGrQr��block_shaperer}r=r=r@r7�s

zBlockManager._make_na_blockrP)r`�verifyr�cCs�|j�t|t�r*tj|j|j|jdd�ntj|dd�}|j	|}|rPt
||�}|rp|dk||kBj�rptd��|j
|j|�}|j|||dd�S)z,
        Take items along any axis.
        r&)rerPz5Indices must be nonzero and less than the axis lengthT)r-rmr`r�rf)r�rRrVrgrn�start�stop�step�
asanyarrayr_r'ro�	Exceptionr6r�r�)rGrmr`r=r�r�rar=r=r@r��s"

zBlockManager.takecCs|j|j}}t|�t|�kr"dStdd�t||�D��s>dS|jdkr�|jdkrVdS|jdj}|jdj}t|j|j�s�dSt	|t
�r�|j|�St||�Sxlt
t|j��D]Z}|j|�}|j|�}t|j|j�s�dSt	|t
��r�|j|��sdSq�t||dd�s�dSq�WdS)NFcss|]\}}|j|�VqdS)N)�equals)r>Zax1Zax2r=r=r@r^�sz&BlockManager.equals.<locals>.<genexpr>rPrT)Zdtype_equal)r6r]r�r�rDr7rTrrerRr#rCr!r�rsr)rGr�Z	self_axesZ
other_axes�left�rightr�r=r=r@rC�s4






zBlockManager.equalscCs�|j|j�}|j}g}g}xX|jD]N}|j|jj}|j|�}	|j|	�}
|j|||
d�\}}|j|�|j|�q"W||}t	|||g�}
|
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
        )�
new_placement)
Zget_new_columnsrsr1r7rlrmZget_indexerZ_unstackr�r5)rGZ	unstackerr�Znew_columnsr1r�Zcolumns_maskrXZblk_colsZ	new_itemsrFr7r�r�r=r=r@�unstack�s


zBlockManager.unstack)T)N)N)rTFr�NN)Tr)Fr�)TTTTF)FF)F)F)T)r)T)T)F)NNNT)NFTT)N)rPTT)]r��
__module__�__qualname__�__doc__�	__slots__rgr�r:r;rr*r(r�rI�classmethodrrK�propertyrMrNr4r[r\�__bool__r	r�r_rDrcrdrLrsryr~r�r�r�r
r�rFr�r3r�r�r"r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rVr�r�r�r
rr�r	rrrr�r�rrrrr'rr,r2r�r�r7r�rCrGr=r=r=r@r5Es�
1

2_
7
	
5$#$w;6r
"c@s<eZdZdZdZdZdZfZdZde	j
feee
d�dd�Zeeeeedd�d	d
��Zeeedd�dd
��Zdd�Zeed�dd��Zedd��Zedd��Zd2eedd�dd�Zeed�dd��Zeed�dd��Zej d�dd �Z!d!d"�Z"d#d$�Z#ee
d�d%d&��Z$e
d�d'd(�Z%d)d*�Z&d+d,�Z'd-d.�Z(d/d0�Z)d1S)3rSz manage a single block with rPTF)rHr`r<cCs^t|t�stt|���t|t�s,tt|���|tjk	rFtjdt	dd�|g|_
t|g�|_dS)NzMThe `fastpath` keyword is deprecated and will be removed in a future version.r�)�
stacklevel)
rRr*rErWr(r
r�warnings�warn�
FutureWarningr6rCr7)rGrHr`r<Zfastpathr=r=r@rIs
zSingleBlockManager.__init__)r7r6rOcCs6t|�dkst�t|�dks t�||d|ddd�S)zZ
        Constructor for BlockManager and SingleBlockManager with same signature.
        rPrF)r<)r]rE)rJr7r6r=r=r@rKszSingleBlockManager.from_blocks)ru�indexrOcCs"t|tdt|��dd�}|||�S)zN
        Constructor for if we have an array that is not yet a Block.
        rrP)rQrD)r2rVr])rJrurSrHr=r=r@�
from_array%szSingleBlockManager.from_arraycCsdS)Nr=)rGr=r=r@r�-sz!SingleBlockManager._post_setstate)rOcCs
|jdS)Nr)r7)rGr=r=r@�_block0szSingleBlockManager._blockcCsdS)z compat with BlockManager Nr=)rGr=r=r@r:4szSingleBlockManager._blknoscCsdS)z compat with BlockManager Nr=)rGr=r=r@r;9szSingleBlockManager._blklocsr)r�r`rOcCsN||jkrtd��|j}|j|�}|j|tdt|��d�}t|�||j|�S)Nz#Requested axis not found in managerr)rQ)	rDr�rUZ_slicerUrVr]rWrS)rGr�r`rXrurHr=r=r@r�>s

zSingleBlockManager.get_slicecCs
|jdS)Nr)r6)rGr=r=r@rSGszSingleBlockManager.indexcCs|jjS)N)rUre)rGr=r=r@reKszSingleBlockManager.dtypecCstj|jjg�S)N)rgrurUre)rGr=r=r@ryOszSingleBlockManager.get_dtypescCs
|jj�S)z$The array that Series.values returns)rU�external_values)rGr=r=r@rVRsz"SingleBlockManager.external_valuescCs
|jj�S)z%The array that Series._values returns)rU�internal_values)rGr=r=r@rWVsz"SingleBlockManager.internal_valuescCs|jjS)N)rU�_can_hold_na)rGr=r=r@rXZszSingleBlockManager._can_hold_nacCsdS)NTr=)rGr=r=r@r�^sz"SingleBlockManager.is_consolidatedcCsdS)Nr=)rGr=r=r@r�asz%SingleBlockManager._consolidate_checkcCsdS)Nr=)rGr=r=r@r�dsz'SingleBlockManager._consolidate_inplacecCs&|jj|�|jdj|�|jd<dS)zy
        Delete single location from SingleBlockManager.

        Ensures that self.blocks doesn't become empty.
        rN)rUrr6)rGrmr=r=r@rgszSingleBlockManager.ideletecCstd��dS)zY
        fast path for getting a cross-section
        return a view of the data
        zUse series._values[loc] insteadN)r�)rGrr=r=r@rpszSingleBlockManager.fast_xsN)r)*r�rHrIrJrDr9r8rKrdr
rr*r(r�rIrLrrKrrTr�rMrUr:r;rVr�r�rSrrergr�ryrVrWrXr�r�r�rrr=r=r=r@rS�sB		rS)r6rOcCs�ydt|�dkrPt|dt�rPt|d�s0g}n t|dtdt|d��d�g}t||�}|j�|Stk
r�}zBdd�|D�}tdd�|D��}t	||dj
dd�||��WYdd}~XnXdS)NrPr)rTrQcSsg|]}t|d|��qS)rT)r�)r>rzr=r=r@rA�sz4create_block_manager_from_blocks.<locals>.<listcomp>css|]}|jdVqdS)rN)r_)r>rzr=r=r@r^�sz3create_block_manager_from_blocks.<locals>.<genexpr>)r]rRr*r2rVr5r�rbr�r�r_)r7r6�mgr�er�r=r=r@� create_block_manager_from_blocks|s 
r[)�namesr6rOcCs�t|t�st�t|t�st�tdd�|D��s2t�y"t|||�}t||�}|j�|Stk
r�}zt	t
|�|dj||��WYdd}~XnXdS)Ncss|]}t|t�VqdS)N)rRr()r>r�r=r=r@r^�sz3create_block_manager_from_arrays.<locals>.<genexpr>r)rRr(rEr|r��form_blocksr5r�rbr�r]r_)�arraysr\r6r7rYrZr=r=r@� create_block_manager_from_arrays�s
r_cCs�ttt|gt|���}t|�dkr2|ddd
�}tdd�|D��}t|�dkr^|ddd�}||krr|dk	rr|S|ddkr�td�Std|�d	|���S)z0 raise a helpful message about our construction r�NrPcss|]}t|�VqdS)N)r])r>r?r=r=r@r^�sz%construction_error.<locals>.<genexpr>rz)Empty data passed with indices specified.zShape of passed values is z, indices imply rfrf)rC�mapr�r|r]rb)r�r<r6rZZpassedZimpliedr=r=r@r��sr�)r\rOcCs�tt�}g}|}|j|d�r.tjt|��}n"|j|d�jsBt�|j	|d�}xVt
|�D]J\}}|dkrv|j|�qZ||}	||}
t|
�}||j
j||	|
f�qZWg}t|d�r�t|d�}
|j|
�t|d�r�t|d�}|j|�t|d��rt|d�}|j|�t|d��r8t|d�}|j|�t|d��r^t|dt�}|j|�t|d��r�d	d
�|dD�}|j|�t|d��r�t|dtj�}|j|�t|d�dk�r�t|dtj�}|j|�t|d
�dk�r
dd
�|d
D�}|j|�t|d��r4dd
�|dD�}|j|�t|d��r^dd
�|dD�}|j|�t|��r�t|�ftdd�|dd�D��}tj|td�}|jtj�t||d�}|j|�|S)NrrPZ
FloatBlockZComplexBlockZTimeDeltaBlockZIntBlockZ
DatetimeBlockr,cSs g|]\}}}t|t|d��qS))�klassrQ)r2r,)r>r�rrur=r=r@rA�szform_blocks.<locals>.<listcomp>Z	BoolBlockZObjectBlockr+cSs g|]\}}}t|t|d��qS))rarQ)r2r+)r>r�rrur=r=r@rA�sr-cSs g|]\}}}t|t|d��qS))rarQ)r2r-)r>r�rrur=r=r@rAsr.cSs g|]\}}}t|t|d��qS))rarQ)r2r.)r>r�rrur=r=r@rA
scss|]}t|�VqdS)N)r])r>r�r=r=r@r^szform_blocks.<locals>.<genexpr>)re)rQrf)rr|rCrgrnr]�intersectionZ	is_uniquerEZget_indexer_forrkr�r1r��_multi_blockifyr��_simple_blockifyrrZobject_rCrhr
rjr;r2)r^r\r6Z
items_dictZ
extra_locsZ	names_idxZ
names_indexerr�Zname_idxr��vZ
block_typer7Zfloat_blocksZcomplex_blocksZtimedelta_blocksZ
int_blocksZdatetime_blocksZdttz_blocksZbool_blocksZ
object_blocksZ
cat_blocksZexternal_blocksr_r}Zna_blockr=r=r@r]�sx












$
r])rOcCs<t||�\}}|dk	r*|j|kr*|j|�}t||d�}|gS)zr
    return a single array of a block that has a single dtype; if dtype is
    not None, coerce to this dtype
    N)rQ)�
_stack_arraysrer�r2)�tuplesrerTrQrHr=r=r@rds

rdcCsRtj|dd��}g}x8|D]0\}}tt|�|�\}}t||d�}|j|�qW|S)zB return an array of blocks that potentially have different dtypes cSs
|djS)Nr�)re)r�r=r=r@�<lambda>/sz!_multi_blockify.<locals>.<lambda>)rQ)�	itertools�groupbyrfr|r2r�)rgre�grouperr�Z	tup_blockrTrQrHr=r=r@rc,srccCspdd�}dd�}t|�\}}}|d}t|�f||�}tj||d�}	x t|�D]\}
}||�|	|
<qPW|	|fS)NcSst|t�r|jStj|�SdS)N)rRr r�rgr)r�r=r=r@�_asarray_compat?s
z&_stack_arrays.<locals>._asarray_compatcSst|t�rt|�fS|jSdS)N)rRr r]r_)r�r=r=r@�
_shape_compatEs

z$_stack_arrays.<locals>._shape_compatr)re)r�r]rgrhrk)rgrerlrmrQr\r^�firstr_Zstackedr�rYr=r=r@rf<srf)r7rOcCst|�sdStdd�|D��S)z�
    Find the common dtype for `blocks`.

    Parameters
    ----------
    blocks : List[Block]

    Returns
    -------
    dtype : np.dtype, ExtensionDtype, or None
        None is returned when `blocks` is empty.
    NcSsg|]
}|j�qSr=)re)r>rzr=r=r@rAgsz&_interleaved_dtype.<locals>.<listcomp>)r]r)r7r=r=r@rWs
rcCsVdd�}tjt||d�|�}g}x0|D](\\}}}tt|�||d�}t||�}q&W|S)zJ
    Merge blocks having same dtype, exclude non-consolidating blocks
    cSs|jS)N)Z_consolidate_key)r�r=r=r@rhosz_consolidate.<locals>.<lambda>)r�)re�can_consolidate)rirj�sorted�
_merge_blocksr|r/)r7Zgkeyrkr�r�reZgroup_blocksZ
merged_blocksr=r=r@rjsr)r7rerorOcCs�t|�dkr|S|r�|dkr:tdd�|D��dkr:td��tjdd�|D��}tjdd�|D��}tj|�}||}||}t||d�gS|S)	NrPcSsh|]
}|j�qSr=)re)r>rzr=r=r@r��sz _merge_blocks.<locals>.<setcomp>z_merge_blocks are invalid!cSsg|]}|jj�qSr=)rlr�)r>rzr=r=r@rA�sz!_merge_blocks.<locals>.<listcomp>cSsg|]
}|j�qSr=)rT)r>rzr=r=r@rA�s)rQ)r]rErgr�Zvstack�argsortr2)r7reror/Z
new_valuesrrr=r=r@rq{s
rqF)�arzr�r�rOcs�tttfttttfd�dd�}|s4�fdd�}ntj�fdd��}|dkr|t|tj�r|t�tj�r|tj	t
|�|j�}t|tj�r�||}t|��s�t
|��r�|d|��dS||�}t|tj�r�|dk	r�tj|jtjd	�}|||<|}|||��|S)
a�
    Compare two array_like inputs of the same shape or two scalar values

    Calls operator.eq or re.search, depending on regex argument. If regex is
    True, perform an element-wise regex matching.

    Parameters
    ----------
    a : array_like
    b : scalar or regex pattern
    regex : bool, default False
    mask : array_like or None (default)

    Returns
    -------
    mask : array_like of bool
    )r�rsrzcSsnt|�rjt|tj�rjt|�jt|�jg}t|tj�rFd|j�d�|d<tdt|d��dt|d�����dS)z�
        Raises an error if the two arrays (a,b) cannot be compared.
        Otherwise, returns the comparison result as expected.
        zndarray(dtype=rBrzCannot compare types z and rPN)	rrRrgr�rWr�rer+�repr)r�rsrz�
type_namesr=r=r@�_check_comparison_types�sz9_compare_or_regex_search.<locals>._check_comparison_typescstj|��S)N)�operator�eq)r�)rzr=r@rh�sz*_compare_or_regex_search.<locals>.<lambda>cs,t|t�r(t�ttf�r(ttj�|��SdS)NF)rRr
rr��re�search)r�)rzr=r@rh�s(NF)re)rrr�rrrgZ	vectorizerRr�rr"r_rrrr)rsrzr�r�rv�opr��tmpr=)rzr@r��s&""r�)rYrOcCs0tj|jtj��}|j�d}tj|||fS)z:Faster version of set(arr) for sequences of small numbers.r)rgZbincountr��int_rZc_)rY�countsZnzr=r=r@r�sr)�lengthrtcCsrt|t�rd|tj||�fSt|tj�rB|jtjkrBd||j�fStj	|tj
d�}|s`t||�}d|t|�fSdS)NrVr�)reZfancy)
rRrVr$Z	slice_lenrgr�rerr�rAr&r'r])r9rrtrmr=r=r@r6�s

r6)N)N)FN)f�collectionsrrirwryZtypingrrrrrrr	r
rrPZnumpyrgZpandas._libsrr$r
Zpandas._typingrrrrZpandas.util._validatorsrZpandas.core.dtypes.castrrrZpandas.core.dtypes.commonrrrrrrrZpandas.core.dtypes.concatrZpandas.core.dtypes.dtypesrZpandas.core.dtypes.genericrr Zpandas.core.dtypes.missingr!r"Zpandas.core.algorithms�coreZ
algorithmsrvZpandas.core.arraysr#Zpandas.core.arrays.sparser$Zpandas.core.baser%Zpandas.core.common�commonr�Zpandas.core.constructionr&Zpandas.core.indexersr'Zpandas.core.indexes.apir(r)Zpandas.core.internals.blocksr*r+r,r-r.r/r0r1r2Zpandas.core.internals.opsr3r4r5rSr[r_r�r]rdrcrfrrr�rqr�r�rr�r6r=r=r=r@�<module>sr,$	,B
a

E