HOME

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

���h�/�@shddlmZmZmZmZmZddlZddlm	Z	ddl
mZddlm
Z
ddlmZmZddlmZddlmZmZmZmZmZmZmZmZmZdd	lmZdd
lm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&j'j(Z)ddl*m+Z,dd
l-m.Z.m/Z/m0Z0ddl1m2Z2e�r
ddl3m4Z4e5dd�Z6Gdd�d�Z7e7�Z8Gdd�de9�Z:Gdd�d�Z;Gdd�de�Z<ee;j=�Gdd�de<��Z>ee;j?�Gdd�de<��Z@Gdd�de�ZAee;jB�Gdd�deA��ZCee;jD�Gd d!�d!eA��ZEeFeeeee5fd"fd#�d$d%�ZGd&d'�d(d)�ZHe2ejId*�d+d,�ZJd-d.�ZKd/d0�ZLd1d2�ZMeNd3�d4d5�ZOeNd3�d6d7�ZPeNd3�d8d9�ZQd:d;�ZRd?d=d>�ZSdS)@�)�
TYPE_CHECKING�Hashable�List�Tuple�UnionN)�option_context)�_NDFrameIndexerBase)�item_from_zerodim)�AbstractMethodError�InvalidIndexError)�doc)	�
is_array_like�is_hashable�
is_integer�is_iterator�is_list_like�is_numeric_dtype�is_object_dtype�	is_scalar�is_sequence)�
concat_compat)�ABCDataFrame�
ABCMultiIndex�	ABCSeries)�_infer_fill_value�isna)�array)�check_array_indexer�is_list_like_indexer�length_of_indexer)�Index)�	DataFramec@seZdZdZdd�ZdS)�_IndexSlicea
    Create an object to more easily perform multi-index slicing.

    See Also
    --------
    MultiIndex.remove_unused_levels : New MultiIndex with no unused levels.

    Notes
    -----
    See :ref:`Defined Levels <advanced.shown_levels>`
    for further info on slicing a MultiIndex.

    Examples
    --------
    >>> midx = pd.MultiIndex.from_product([['A0','A1'], ['B0','B1','B2','B3']])
    >>> columns = ['foo', 'bar']
    >>> dfmi = pd.DataFrame(np.arange(16).reshape((len(midx), len(columns))),
                            index=midx, columns=columns)

    Using the default slice command:

    >>> dfmi.loc[(slice(None), slice('B0', 'B1')), :]
               foo  bar
        A0 B0    0    1
           B1    2    3
        A1 B0    8    9
           B1   10   11

    Using the IndexSlice class for a more intuitive command:

    >>> idx = pd.IndexSlice
    >>> dfmi.loc[idx[:, 'B0':'B1'], :]
               foo  bar
        A0 B0    0    1
           B1    2    3
        A1 B0    8    9
           B1   10   11
    cCs|S)N�)�self�argr#r#�6/tmp/pip-build-5_djhm0z/pandas/pandas/core/indexing.py�__getitem__Tsz_IndexSlice.__getitem__N)�__name__�
__module__�__qualname__�__doc__r'r#r#r#r&r",s&r"c@seZdZdS)�
IndexingErrorN)r(r)r*r#r#r#r&r,[sr,c@sXeZdZdZedd�dd��Zedd�dd��Zed	d�d
d��Zedd�d
d��ZdS)�
IndexingMixinzH
    Mixin for adding .loc/.iloc/.at/.iat to Dataframes and Series.
    �_iLocIndexer)�returncCs
td|�S)aZ
        Purely integer-location based indexing for selection by position.

        ``.iloc[]`` is primarily integer position based (from ``0`` to
        ``length-1`` of the axis), but may also be used with a boolean
        array.

        Allowed inputs are:

        - An integer, e.g. ``5``.
        - A list or array of integers, e.g. ``[4, 3, 0]``.
        - A slice object with ints, e.g. ``1:7``.
        - A boolean array.
        - A ``callable`` function with one argument (the calling Series or
          DataFrame) and that returns valid output for indexing (one of the above).
          This is useful in method chains, when you don't have a reference to the
          calling object, but would like to base your selection on some value.

        ``.iloc`` will raise ``IndexError`` if a requested indexer is
        out-of-bounds, except *slice* indexers which allow out-of-bounds
        indexing (this conforms with python/numpy *slice* semantics).

        See more at :ref:`Selection by Position <indexing.integer>`.

        See Also
        --------
        DataFrame.iat : Fast integer location scalar accessor.
        DataFrame.loc : Purely label-location based indexer for selection by label.
        Series.iloc : Purely integer-location based indexing for
                       selection by position.

        Examples
        --------
        >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
        ...           {'a': 100, 'b': 200, 'c': 300, 'd': 400},
        ...           {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
        >>> df = pd.DataFrame(mydict)
        >>> df
              a     b     c     d
        0     1     2     3     4
        1   100   200   300   400
        2  1000  2000  3000  4000

        **Indexing just the rows**

        With a scalar integer.

        >>> type(df.iloc[0])
        <class 'pandas.core.series.Series'>
        >>> df.iloc[0]
        a    1
        b    2
        c    3
        d    4
        Name: 0, dtype: int64

        With a list of integers.

        >>> df.iloc[[0]]
           a  b  c  d
        0  1  2  3  4
        >>> type(df.iloc[[0]])
        <class 'pandas.core.frame.DataFrame'>

        >>> df.iloc[[0, 1]]
             a    b    c    d
        0    1    2    3    4
        1  100  200  300  400

        With a `slice` object.

        >>> df.iloc[:3]
              a     b     c     d
        0     1     2     3     4
        1   100   200   300   400
        2  1000  2000  3000  4000

        With a boolean mask the same length as the index.

        >>> df.iloc[[True, False, True]]
              a     b     c     d
        0     1     2     3     4
        2  1000  2000  3000  4000

        With a callable, useful in method chains. The `x` passed
        to the ``lambda`` is the DataFrame being sliced. This selects
        the rows whose index label even.

        >>> df.iloc[lambda x: x.index % 2 == 0]
              a     b     c     d
        0     1     2     3     4
        2  1000  2000  3000  4000

        **Indexing both axes**

        You can mix the indexer types for the index and columns. Use ``:`` to
        select the entire axis.

        With scalar integers.

        >>> df.iloc[0, 1]
        2

        With lists of integers.

        >>> df.iloc[[0, 2], [1, 3]]
              b     d
        0     2     4
        2  2000  4000

        With `slice` objects.

        >>> df.iloc[1:3, 0:3]
              a     b     c
        1   100   200   300
        2  1000  2000  3000

        With a boolean array whose length matches the columns.

        >>> df.iloc[:, [True, False, True, False]]
              a     c
        0     1     3
        1   100   300
        2  1000  3000

        With a callable function that expects the Series or DataFrame.

        >>> df.iloc[:, lambda df: [0, 2]]
              a     c
        0     1     3
        1   100   300
        2  1000  3000
        �iloc)r.)r$r#r#r&r0dszIndexingMixin.iloc�_LocIndexercCs
td|�S)a
        Access a group of rows and columns by label(s) or a boolean array.

        ``.loc[]`` is primarily label based, but may also be used with a
        boolean array.

        Allowed inputs are:

        - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is
          interpreted as a *label* of the index, and **never** as an
          integer position along the index).
        - A list or array of labels, e.g. ``['a', 'b', 'c']``.
        - A slice object with labels, e.g. ``'a':'f'``.

          .. warning:: Note that contrary to usual python slices, **both** the
              start and the stop are included

        - A boolean array of the same length as the axis being sliced,
          e.g. ``[True, False, True]``.
        - A ``callable`` function with one argument (the calling Series or
          DataFrame) and that returns valid output for indexing (one of the above)

        See more at :ref:`Selection by Label <indexing.label>`

        Raises
        ------
        KeyError
            If any items are not found.

        See Also
        --------
        DataFrame.at : Access a single value for a row/column label pair.
        DataFrame.iloc : Access group of rows and columns by integer position(s).
        DataFrame.xs : Returns a cross-section (row(s) or column(s)) from the
            Series/DataFrame.
        Series.loc : Access group of values using labels.

        Examples
        --------
        **Getting values**

        >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
        ...      index=['cobra', 'viper', 'sidewinder'],
        ...      columns=['max_speed', 'shield'])
        >>> df
                    max_speed  shield
        cobra               1       2
        viper               4       5
        sidewinder          7       8

        Single label. Note this returns the row as a Series.

        >>> df.loc['viper']
        max_speed    4
        shield       5
        Name: viper, dtype: int64

        List of labels. Note using ``[[]]`` returns a DataFrame.

        >>> df.loc[['viper', 'sidewinder']]
                    max_speed  shield
        viper               4       5
        sidewinder          7       8

        Single label for row and column

        >>> df.loc['cobra', 'shield']
        2

        Slice with labels for row and single label for column. As mentioned
        above, note that both the start and stop of the slice are included.

        >>> df.loc['cobra':'viper', 'max_speed']
        cobra    1
        viper    4
        Name: max_speed, dtype: int64

        Boolean list with the same length as the row axis

        >>> df.loc[[False, False, True]]
                    max_speed  shield
        sidewinder          7       8

        Conditional that returns a boolean Series

        >>> df.loc[df['shield'] > 6]
                    max_speed  shield
        sidewinder          7       8

        Conditional that returns a boolean Series with column labels specified

        >>> df.loc[df['shield'] > 6, ['max_speed']]
                    max_speed
        sidewinder          7

        Callable that returns a boolean Series

        >>> df.loc[lambda df: df['shield'] == 8]
                    max_speed  shield
        sidewinder          7       8

        **Setting values**

        Set value for all items matching the list of labels

        >>> df.loc[['viper', 'sidewinder'], ['shield']] = 50
        >>> df
                    max_speed  shield
        cobra               1       2
        viper               4      50
        sidewinder          7      50

        Set value for an entire row

        >>> df.loc['cobra'] = 10
        >>> df
                    max_speed  shield
        cobra              10      10
        viper               4      50
        sidewinder          7      50

        Set value for an entire column

        >>> df.loc[:, 'max_speed'] = 30
        >>> df
                    max_speed  shield
        cobra              30      10
        viper              30      50
        sidewinder         30      50

        Set value for rows matching callable condition

        >>> df.loc[df['shield'] > 35] = 0
        >>> df
                    max_speed  shield
        cobra              30      10
        viper               0       0
        sidewinder          0       0

        **Getting values on a DataFrame with an index that has integer labels**

        Another example using integers for the index

        >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
        ...      index=[7, 8, 9], columns=['max_speed', 'shield'])
        >>> df
           max_speed  shield
        7          1       2
        8          4       5
        9          7       8

        Slice with integer labels for rows. As mentioned above, note that both
        the start and stop of the slice are included.

        >>> df.loc[7:9]
           max_speed  shield
        7          1       2
        8          4       5
        9          7       8

        **Getting values with a MultiIndex**

        A number of examples using a DataFrame with a MultiIndex

        >>> tuples = [
        ...    ('cobra', 'mark i'), ('cobra', 'mark ii'),
        ...    ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),
        ...    ('viper', 'mark ii'), ('viper', 'mark iii')
        ... ]
        >>> index = pd.MultiIndex.from_tuples(tuples)
        >>> values = [[12, 2], [0, 4], [10, 20],
        ...         [1, 4], [7, 1], [16, 36]]
        >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)
        >>> df
                             max_speed  shield
        cobra      mark i           12       2
                   mark ii           0       4
        sidewinder mark i           10      20
                   mark ii           1       4
        viper      mark ii           7       1
                   mark iii         16      36

        Single label. Note this returns a DataFrame with a single index.

        >>> df.loc['cobra']
                 max_speed  shield
        mark i          12       2
        mark ii          0       4

        Single index tuple. Note this returns a Series.

        >>> df.loc[('cobra', 'mark ii')]
        max_speed    0
        shield       4
        Name: (cobra, mark ii), dtype: int64

        Single label for row and column. Similar to passing in a tuple, this
        returns a Series.

        >>> df.loc['cobra', 'mark i']
        max_speed    12
        shield        2
        Name: (cobra, mark i), dtype: int64

        Single tuple. Note using ``[[]]`` returns a DataFrame.

        >>> df.loc[[('cobra', 'mark ii')]]
                       max_speed  shield
        cobra mark ii          0       4

        Single tuple for the index with a single label for the column

        >>> df.loc[('cobra', 'mark i'), 'shield']
        2

        Slice from index tuple to single label

        >>> df.loc[('cobra', 'mark i'):'viper']
                             max_speed  shield
        cobra      mark i           12       2
                   mark ii           0       4
        sidewinder mark i           10      20
                   mark ii           1       4
        viper      mark ii           7       1
                   mark iii         16      36

        Slice from index tuple to index tuple

        >>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]
                            max_speed  shield
        cobra      mark i          12       2
                   mark ii          0       4
        sidewinder mark i          10      20
                   mark ii          1       4
        viper      mark ii          7       1
        �loc)r1)r$r#r#r&r2�sozIndexingMixin.loc�
_AtIndexercCs
td|�S)a�
        Access a single value for a row/column label pair.

        Similar to ``loc``, in that both provide label-based lookups. Use
        ``at`` if you only need to get or set a single value in a DataFrame
        or Series.

        Raises
        ------
        KeyError
            If 'label' does not exist in DataFrame.

        See Also
        --------
        DataFrame.iat : Access a single value for a row/column pair by integer
            position.
        DataFrame.loc : Access a group of rows and columns by label(s).
        Series.at : Access a single value using a label.

        Examples
        --------
        >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
        ...                   index=[4, 5, 6], columns=['A', 'B', 'C'])
        >>> df
            A   B   C
        4   0   2   3
        5   0   4   1
        6  10  20  30

        Get value at specified row/column pair

        >>> df.at[4, 'B']
        2

        Set value at specified row/column pair

        >>> df.at[4, 'B'] = 10
        >>> df.at[4, 'B']
        10

        Get value within a Series

        >>> df.loc[5].at['B']
        4
        �at)r3)r$r#r#r&r4�s/zIndexingMixin.at�_iAtIndexercCs
td|�S)a�
        Access a single value for a row/column pair by integer position.

        Similar to ``iloc``, in that both provide integer-based lookups. Use
        ``iat`` if you only need to get or set a single value in a DataFrame
        or Series.

        Raises
        ------
        IndexError
            When integer position is out of bounds.

        See Also
        --------
        DataFrame.at : Access a single value for a row/column label pair.
        DataFrame.loc : Access a group of rows and columns by label(s).
        DataFrame.iloc : Access a group of rows and columns by integer position(s).

        Examples
        --------
        >>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
        ...                   columns=['A', 'B', 'C'])
        >>> df
            A   B   C
        0   0   2   3
        1   0   4   1
        2  10  20  30

        Get value at specified row/column pair

        >>> df.iat[1, 2]
        1

        Set value at specified row/column pair

        >>> df.iat[1, 2] = 10
        >>> df.iat[1, 2]
        10

        Get value within a series

        >>> df.loc[0].iat[1]
        2
        �iat)r5)r$r#r#r&r6s.zIndexingMixin.iatN)	r(r)r*r+�propertyr0r2r4r6r#r#r#r&r-_s	p0r-c@seZdZUedZd.dd�Zdd�Zd/dd�Zdd	�Z	e
d
�dd�Zed
�dd�Z
eed�dd�Zd0ed�dd�Zed�dd�Zed�dd�Zed�dd�Zd1e
ed�dd �Zd!d"�Zed
�d#d$�Zed�d%d&�Ze
d
�d'd(�Zed)�d*d+�Ze
d
�d,d-�ZdS)2�_LocationIndexerNcCs0t|�|j|j�}|dk	r&|jj|�}||_|S)N)�type�name�obj�_get_axis_number�axis)r$r=Znew_selfr#r#r&�__call__Cs
z_LocationIndexer.__call__c Cs|jdkr|j|�|jdk	r,|j|dd�S|jjd�}t|t�rr|jdkrry
|j|�St	t
tfk
rpYnXt|t�r�y|j|dd�St
k
r�YnXt|t�r�t|�Sy|j|ddd�St	k
�r}z0dt|�kr�nd	t|�k�r��t
|�|�WYdd}~XnXdS)
zR
        Convert a potentially-label-based key into a positional indexer.
        r2NT)�	is_setterrr0)r=r?z	cannot dozunhashable type)r:�_ensure_listlike_indexerr=�_convert_tupler;�	_get_axis�
isinstancer�get_loc�	TypeError�KeyErrorr�tupler,�range�list�_convert_to_indexer�str)r$�key�ax�er#r#r&�_get_setitem_indexerLs2





z%_LocationIndexer._get_setitem_indexercCs�d}|jdkrdSt|t�r8t|jjt�r8||}|}||kr�t|jjt�r�t|�r�tj	|�r�t
dd�|D��r�x"|D]}||jkr|tj|j|<q|WdS)a
        Ensure that a list-like of column labels are all present by adding them if
        they do not already exist.

        Parameters
        ----------
        key : list-like of column labels
            Target labels.
        axis : key axis if known
        ��Ncss|]}t|�VqdS)N)r)�.0�kr#r#r&�	<genexpr>�sz<_LocationIndexer._ensure_listlike_indexer.<locals>.<genexpr>)
�ndimrCrGr;�indexr�columnsr�com�is_bool_indexer�all�np�nan)r$rLr=Zcolumn_axisrSr#r#r&r@ss


z)_LocationIndexer._ensure_listlike_indexercsjt|t�r"t�fdd�|D��}ntj|�j�}�j|�}�j|��jdkrR�n�jj}|j	||�dS)Nc3s|]}tj|�j�VqdS)N)rX�apply_if_callabler;)rR�x)r$r#r&rT�sz/_LocationIndexer.__setitem__.<locals>.<genexpr>r0)
rCrGrXr]r;rO�_has_valid_setitem_indexerr:r0�_setitem_with_indexer)r$rL�value�indexerr0r#)r$r&�__setitem__�s


z_LocationIndexer.__setitem__)r=cCst|��dS)a�
        Ensure that key is valid for current indexer.

        Parameters
        ----------
        key : scalar, slice or list-like
            Key requested.
        axis : int
            Dimension on which the indexing is being made.

        Raises
        ------
        TypeError
            If the key (or some element of it) has wrong type.
        IndexError
            If the key (or some element of it) is out of bounds.
        KeyError
            If the key was not found.
        N)r
)r$rLr=r#r#r&�
_validate_key�sz_LocationIndexer._validate_key)rLcCstxnt|�D]b\}}||jkr$td��y|j||�Wq
tk
rj}ztd|j�d��|�WYdd}~Xq
Xq
WdS)zA
        Check the key for valid keys across my indexer.
        zToo many indexersz'Location based indexing can only have [z] typesN)�	enumeraterUr,rd�
ValueError�_valid_types)r$rL�irS�errr#r#r&�_has_valid_tuple�s
z!_LocationIndexer._has_valid_tuple)�tupr/cs4tdd�|jjD��r0t�fdd�|jjD��SdS)z6
        Returns
        -------
        bool
        css|]}t|t�VqdS)N)rCr)rRrMr#r#r&rT�sz<_LocationIndexer._is_nested_tuple_indexer.<locals>.<genexpr>c3s|]}t�|�VqdS)N)�is_nested_tuple)rRrM)rkr#r&rT�sF)�anyr;�axes)r$rkr#)rkr&�_is_nested_tuple_indexer�sz)_LocationIndexer._is_nested_tuple_indexerF)r?cCs�g}|jdk	r`|jj|j�}x�t|j�D]2}||krL|j|j|||d��q(|jtd��q(WnBx@t|�D]4\}}||jkr�t	d��|j|||d�}|j|�qjWt
|�S)N)r=r?zToo many indexers)r=r;r<rHrU�appendrJ�slicerer,rG)r$rLr?Zkeyidxr=rhrS�idxr#r#r&rA�s

z_LocationIndexer._convert_tuple)rkcCsR|j}xFt|�D]:\}}tj|�r$qt||j�j||d�}|j|jkst�qW|S)z�
        Index with indexers that should return an object of the same dimension
        as self.obj.

        This is only called after a failed call to _getitem_lowerdim.
        )r=)	r;rerX�
is_null_slice�getattrr:�
_getitem_axisrU�AssertionError)r$rk�retvalrhrLr#r#r&�_getitem_tuple_same_dim�s
z(_LocationIndexer._getitem_tuple_same_dimc	
CsN|jdk	r&|jj|j�}|j||d�S|j|�r:|j|�S|jjd�}t|t�r~|j	dkr~y|j
|�}|Stk
r|YnXt|�|j
kr�td��x�t|�D]�\}}t|�r�|j||d�}|j
|j
kr�|d|�tf||dd�}n2|d|�||dd�}t|�dk�r|d}tj|��r.|St||j	�|Sq�Wtd��dS)N)r=rr0z#Too many indexers. handle elsewhererPznot applicable)r=r;r<ruro�_getitem_nested_tuplerBrCrr:�"_handle_lowerdim_multi_index_axis0r,�lenrUre�
is_label_like�_NSrXrsrt)	r$rkr=Zax0�resultrhrL�sectionZnew_keyr#r#r&�_getitem_lowerdim�s4



$z"_LocationIndexer._getitem_lowerdimc
Cs�t|�|jkr\|jdkr td��y|j|�}|Stk
rBYnX|jpLd}|j||d�S|j}d}xl|D]d}t	j
|�r�|d7}ql|j}t||j�j||d�}|d7}t|�s�t
|d�r�P|j|krl|d8}qlW|S)Nr2zToo many indicesr)r=rPrU)r{rUr:rfrzr,r=rur;rXrsrtr�hasattr)r$rkr~r=r;rLZcurrent_ndimr#r#r&ry.s0





z&_LocationIndexer._getitem_nested_tuple)r=r?cCst|��dS)N)r
)r$rLr=r?r#r#r&rJ]sz$_LocationIndexer._convert_to_indexerc
s�t|�tkrft�fdd�|D��}�j|�r\y�jj|d�ji�Stttfk
rZYnX�j	|�S�j
pnd}tj|�j�}�j
||d�SdS)Nc3s|]}tj|�j�VqdS)N)rXr]r;)rRr^)r$r#r&rTbsz/_LocationIndexer.__getitem__.<locals>.<genexpr>�takeabler)r=)r9rG�_is_scalar_accessr;�
_get_value�	_takeablerF�
IndexError�AttributeError�_getitem_tupler=rXr]ru)r$rLr=Zmaybe_callabler#)r$r&r'`s


z_LocationIndexer.__getitem__cCs
t��dS)N)�NotImplementedError)r$rLr#r#r&r�qsz"_LocationIndexer._is_scalar_accesscCst|��dS)N)r
)r$rkr#r#r&r�tsz_LocationIndexer._getitem_tuplecCs
t��dS)N)r�)r$rLr=r#r#r&ruwsz_LocationIndexer._getitem_axis)r/cCst|��dS)N)r
)r$rbr#r#r&r_zsz+_LocationIndexer._has_valid_setitem_indexercCs2|jj|�}t||�}|j�d}|jj||d�S)Nr)r=)r;rB�check_bool_indexer�nonzero�_take_with_is_copy)r$rLr=�labels�indsr#r#r&�
_getbool_axis}s
z_LocationIndexer._getbool_axis)N)N)F)F)r(r)r*rKrgr=r>rOr@rc�intrdrrj�boolrorArxr�ryrJr'r�r�rur_r�r#r#r#r&r8?s(

	'
"
9/r8c@s�eZdZUdZedZeej�e	d�dd��Zed�dd�Z
eed	�d
d�Zeed�d
d�Z
ed�dd�Ze	d�dd�Zed�dd�Ze	d�dd�Zed�dd�Ze	d�dd�Zee	d�dd�Zd(e	ed�d d!�Zd)e	ed"�d#d$�Zd*e	ed"�d%d&�Zd'S)+r1Fz�labels (MUST BE IN THE INDEX), slices of labels (BOTH endpoints included! Can be slices of integers if the index is integers), listlike of labels, boolean)r=cCsdS)Nr#)r$rLr=r#r#r&rd�sz_LocIndexer._validate_key)r/cCsdS)NTr#)r$rbr#r#r&r_�sz&_LocIndexer._has_valid_setitem_indexer)rLr/cCspt|�|jkrdSxXt|�D]L\}}t|�s0dS|jj|}t|t�rJdSt|t�r^|j	r^dS|j
sdSqWdS)z6
        Returns
        -------
        bool
        FT)r{rUrerr;rnrCrrK�!_supports_partial_string_indexing�	is_unique)r$rLrhrSrMr#r#r&r��s

z_LocIndexer._is_scalar_access)rkr/cCs0tdd�|D��sdStdd�|D��r,dSdS)a�
        Check whether there is the possibility to use ``_multi_take``.

        Currently the limit is that all axes being indexed, must be indexed with
        list-likes.

        Parameters
        ----------
        tup : tuple
            Tuple of indexers, one per axis.

        Returns
        -------
        bool
            Whether the current indexing,
            can be passed through `_multi_take`.
        css|]}t|�VqdS)N)r)rRr^r#r#r&rT�sz6_LocIndexer._multi_take_opportunity.<locals>.<genexpr>Fcss|]}tj|�VqdS)N)rXrY)rRr^r#r#r&rT�sT)rZrm)r$rkr#r#r&�_multi_take_opportunity�s
z#_LocIndexer._multi_take_opportunity)rkcs.�fdd�t|�jj�D�}�jj|ddd�S)a�
        Create the indexers for the passed tuple of keys, and
        executes the take operation. This allows the take operation to be
        executed all at once, rather than once for each dimension.
        Improving efficiency.

        Parameters
        ----------
        tup : tuple
            Tuple of indexers, one per axis.

        Returns
        -------
        values: same type as the object being indexed
        csi|]\}}�j||�|�qSr#)�_get_listlike_indexer)rRrLr=)r$r#r&�
<dictcomp>�sz+_LocIndexer._multi_take.<locals>.<dictcomp>T)�copy�
allow_dups)�zipr;Z_AXIS_ORDERS�_reindex_with_indexers)r$rk�dr#)r$r&�_multi_take�s
z_LocIndexer._multi_takecCs:|j||�|j||dd�\}}|jj|||giddd�S)a�
        Index current object with an an iterable collection of keys.

        Parameters
        ----------
        key : iterable
            Targeted labels.
        axis: int
            Dimension on which the indexing is being made.

        Raises
        ------
        KeyError
            If no key was found. Will change in the future to raise if not all
            keys were found.

        Returns
        -------
        scalar, DataFrame, or Series: indexed value(s).
        F)�
raise_missingT)r�r�)rdr�r;r�)r$rLr=�keyarrrbr#r#r&�_getitem_iterable�sz_LocIndexer._getitem_iterablecCsHy
|j|�Stk
rYnX|j|�|j|�r>|j|�S|j|�S)N)r�r,rjr�r�rx)r$rkr#r#r&r�s



z_LocIndexer._getitem_tuplecCs|jj||d�S)N)r=)r;�xs)r$�labelr=r#r#r&�
_get_label!sz_LocIndexer._get_labelcCs�|jpd}y|j||d�Sttfk
r0YnFtk
rt}z*t|�|jjjkrdt|�|j	krd|�WYdd}~XnXt
d��dS)Nr)r=zNo label returned)r=r�rErrFr{r;rV�nlevelsrUr,)r$rkr=Zekr#r#r&rz%s
 z._LocIndexer._handle_lowerdim_multi_index_axis0cCst|�}t|�rt|�}|jj|�}|j|�}t|t�rR|j||�|j	||d�St
j|�rj|j||d�St
|�r�t|t�o�t|t�s�t|d�r�|jdkr�td��|j||d�St||�r�|j|�}td�g|j}|||<|jjt|�S|j||�|j||d�S)N)r=rUrPz&Cannot index with multidimensional key)r	rrIr;rBZ'_get_partial_string_timestamp_match_keyrCrqrd�_get_slice_axisrXrYr�rrGrr�rUrfr�rl�get_locsr0r�)r$rLr=r�Zlocsrbr#r#r&ru6s,




z_LocIndexer._getitem_axis)�	slice_objr=cCsj|j}t|�s|jdd�S|j|�}|j|j|j|jdd�}t|t	�rV|jj
||d�S|jj||d�SdS)zL
        This is pretty simple as we just have to deal with labels.
        F)�deepr2)�kind)r=N)r;�
need_slicer�rBZ
slice_indexer�start�stop�steprCrq�_sliceZtake)r$r�r=r;r�rbr#r#r&r�Xs

z_LocIndexer._get_slice_axis)r=r?cCs�|jj|�}t|t�r$|j|dd�S|j�}t|�o8|}t|�sLt|t�r�y
|j|�St	k
r�t|t
�r�t|t�r�t|�|jkr�d|iS�YnJt
k
r�t|t�s��Yn,tk
r�Yntk
r�|sڂYnX|r�d|iSt||��r|j|�St|��rFtj|��r0t||�}|j�\}|S|j||dd�dSn6y
|j|�St	k
�rzt|��std|iS�YnXdS)a�
        Convert indexing key into something we can use to do actual fancy
        indexing on a ndarray.

        Examples
        ix[:5] -> slice(0, 5)
        ix[[1,2,3]] -> [1,2,3]
        ix[['foo', 'bar', 'baz']] -> [i, j, k] (indices of foo, bar, baz)

        Going by Zen of Python?
        'In the face of ambiguity, refuse the temptation to guess.'
        raise AmbiguousIndexError with integer labels?
        - No, prefer label-based indexing
        r2)r�rLT)r�rPN)r;rBrCrq�_convert_slice_indexerrrrrD�LookupErrorrGr{r�rrErfrlr�rrXrYr�r�r�)r$rLr=r?r�Zis_int_indexZis_int_positionalr�r#r#r&rJmsJ








z_LocIndexer._convert_to_indexer)r=r�cCs�|jj|�}|j|�\}}|dk	rL|dkj�rL|j||||d�|||fS|jrzt|dd�rz|j|�}|j|�d}n|j	|�\}}}|j||||d�||fS)a\
        Transform a list-like of keys into a new index and an indexer.

        Parameters
        ----------
        key : list-like
            Targeted labels.
        axis: int
            Dimension on which the indexing is being made.
        raise_missing: bool, default False
            Whether to raise a KeyError if some labels were not found.
            Will be removed in the future, and then this method will always behave as
            if ``raise_missing=True``.

        Raises
        ------
        KeyError
            If at least one key was requested but none was found, and
            raise_missing=True.

        Returns
        -------
        keyarr: Index
            New index (coinciding with 'key' if the axis is unique).
        values : array-like
            Indexer for the return object, -1 denotes keys not found.
        NrP)r�Zis_overlappingFr���)
r;rBZ_convert_listlike_indexerrZ�_validate_read_indexerr�rtZget_indexer_for�reindexZ_reindex_non_unique)r$rLr=r�rMrbr��new_indexerr#r#r&r��s
z!_LocIndexer._get_listlike_indexerc
Cs�|jj|�}t|�dkrdS|dk}|j�}|r�|t|�kr^|jj|�}td|�d|�d���|r�tt|�t|��}	t|	�d���|j�s�||}	t	ddd	d
��td|	�d���WdQRXdS)
al
        Check that indexer can be used to return a result.

        e.g. at least one element was found,
        unless the list of keys was actually empty.

        Parameters
        ----------
        key : list-like
            Targeted labels (only used to show correct error message).
        indexer: array-like of booleans
            Indices corresponding to the key,
            (with -1 indicating not found).
        axis: int
            Dimension on which the indexing is being made.
        raise_missing: bool
            Whether to raise a KeyError if some labels are not found. Will be
            removed in the future, and then this method will always behave as
            if raise_missing=True.

        Raises
        ------
        KeyError
            If at least one key was requested but none was found, and
            raise_missing=True.
        rNz	None of [z] are in the [�]z
 not in indexzdisplay.max_seq_items�
z
display.width�PztPassing list-likes to .loc or [] with any missing labels is no longer supported. The following labels were missing: zj. See https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#deprecate-loc-reindex-listlike)
r;rBr{�sumZ_get_axis_namerFrI�setZis_categoricalr)
r$rLrbr=r�rMZmissing_mask�missingZ	axis_name�	not_foundr#r#r&r��s"z"_LocIndexer._validate_read_indexerN)F)F)F)r(r)r*r�r�rgrr8rdr�r_rr�r�r�r�r�r�rzrurqr�rJr�r�r#r#r#r&r1�s"
""K2r1c@s�eZdZdZdZed�dd�Zed�dd�Ze	ed	�d
d�Z
eedd
�dd�Ze	d�dd�Zed�dd�Z
ed�dd�Zeed�dd�Zd*eed�dd�Zdd�Zd d!�Zd"d#�Zd+eed$�d%d&�Zed'�d(d)�ZdS),r.zlinteger, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean arrayT)r=cCs�tj|�r@t|d�r<t|jt�r<|jjdkr4td��td��dSt|t	�rNdSt
|�rd|j||�n�t|t�rxt
d��nxt|�r�tj|�}t|jj|��}t|j�s�td|����t|�r�|j�|ks�|j�|kr�td��ntd|j�d	���dS)
NrV�integerzDiLocation based boolean indexing on an integer type is not availablezBiLocation based boolean indexing cannot use an indexable as a maskzToo many indexersz%.iloc requires numeric indexers, got z%positional indexers are out-of-boundsz#Can only index by location with a [r�)rXrYr�rCrVr Z
inferred_typer�rfrqr�_validate_integerrGr,rr[rr{r;rBr�dtyper��max�minrg)r$rLr=Zarr�len_axisr#r#r&rd6s,





"
z_iLocIndexer._validate_key)r/cCs�t|t�rtd��nxt|t�s*t|j|�}x`t|jj|�D]N\}}t|t	�rNq:t
|�rXq:t|�rv|t|�kr�td��q:t|t�r:td��q:WdS)z�
        Validate that a positional indexer cannot enlarge its target
        will raise if needed, does not modify the indexer externally.

        Returns
        -------
        bool
        z%iloc cannot enlarge its target objectT)
rC�dictr�rG�_tuplifyrUr�r;rnrqrrr{)r$rbrMrhr#r#r&r_[s	





z'_iLocIndexer._has_valid_setitem_indexer)rLr/cCs0t|�|jkrdSx|D]}t|�sdSqWdS)z6
        Returns
        -------
        bool
        FT)r{rUr)r$rLrSr#r#r&r�xs

z_iLocIndexer._is_scalar_accessN)rLr=r/cCs.t|jj|��}||ks"||kr*td��dS)a@
        Check that 'key' is a valid position in the desired axis.

        Parameters
        ----------
        key : int
            Requested position.
        axis : int
            Desired axis.

        Raises
        ------
        IndexError
            If 'key' is not a valid position in axis 'axis'.
        z*single positional indexer is out-of-boundsN)r{r;rBr�)r$rLr=r�r#r#r&r��sz_iLocIndexer._validate_integer)rkcCs4|j|�y
|j|�Stk
r(YnX|j|�S)N)rjr�r,rx)r$rkr#r#r&r��s

z_iLocIndexer._getitem_tuplecCsBy|jj||d�Stk
r<}ztd�|�WYdd}~XnXdS)a
        Return Series values by list or array of integers.

        Parameters
        ----------
        key : list-like positional indexer
        axis : int

        Returns
        -------
        Series object

        Notes
        -----
        `axis` can only be zero.
        )r=z%positional indexers are out-of-boundsN)r;r�r�)r$rLr=rir#r#r&�_get_list_axis�sz_iLocIndexer._get_list_axiscCs�t|t�r|j||d�St|t�r,tj|�}tj|�rP|j||�|j	||d�St
|�rf|j||d�St|�}t
|�s~td��|j||�|jj||d�SdS)N)r=z5Cannot index by location index with a non-integer key)rCrqr�rIr[�asarrayrXrYrdr�rr�r	rrEr�r;�_ixs)r$rLr=r#r#r&ru�s



z_iLocIndexer._getitem_axis)r�r=cCs>|j}t|�s|jdd�S|j|�}|j|�|jj||d�S)NF)r�)r=)r;r�r�rBZ_validate_positional_slicer�)r$r�r=r;r�r#r#r&r��s

z_iLocIndexer._get_slice_axisF)r=r?cCs|S)zL
        Much simpler as we only have to deal with our valid types.
        r#)r$rLr=r?r#r#r&rJ�sz _iLocIndexer._convert_to_indexercCs|S)Nr#)r$rLr#r#r&rO�sz!_iLocIndexer._get_setitem_indexercs�ddlm}�jj��jj}|rh�jjjrh�jjj\}d|jkrht|t	�rXt
|j��n|}|j|�}t|t
�r�t|�t�jj�kr�x>t|�jj�D],\�}t|t�r�t��p�tj��r�d}Pq�Wt|t
��rg}�x"t|�D�]\�}	t|	t	��r�t|	�\}
}�jdk�r���k�r��fdd�t�jj�D�}tdd�|D���rht|��sZtd��|�j|
<d	St|��j|
<t|�jj�}
�j|
|�d	S�jj��}|jt|�|
�}�jj|�d
�j�j_�jj dd�d	�j_!|j"|j#|
��q�|j"|	�q�Wt
|�}n"t|�\}}|�r(�j$||�d	S�jj��}|�r��jdk�sJt%��dk�sXt%�t|t
��spt&�j|�}t|t'��r��j(||�}|�}t|��r�|g}||}|}t|t)��r�t*t+t�jj,���}||}|d	d��t-�d�jj.�}t|�dk�r2t|��r2d|k�o"t|�kn�r2td
����fdd�}t|��r�t/|dd�dk�r�t|t0��r�t
|�}t|t�}xP|D]H}||}||k�r�||�<�j(t
|�|||�}nt1j2}|||��q�W�q�t1j|�dk�r>t1j3|t4d�}t|�|j5dk�r
td��x�t|�D]$\�}|||d	d	��fj6���qWn�t|�dk�rz|t|�k�rzt7�d��rz||d|�n`|dk�r�t|�t�jj.�k�r�n>t|�t|�k�r�td��x>t||�D]\}}|||��q�Wnx�|D]}|||��q�Wn�t|t
��rbt|��k�rZt|���rZt8�fdd�t|�D���rZ|j9�rZ|�j||�<d	St:|�}t|t't	f��r��j(|||��}nt|t0��r��j;||�}�jj<��jj=��jjj>||d��j_�jj dd�d	S)a�
        _setitem_with_indexer is for setting values on a Series/DataFrame
        using positional indexers.

        If the relevant keys are not present, the Series/DataFrame may be
        expanded.

        This method is currently broken when dealing with non-unique Indexes,
        since it goes from positional indexers back to labels when calling
        BlockManager methods, see GH#12991, GH#22046, GH#15686.
        r)�SeriesrPTc3s"|]\}}|�krt|�VqdS)N)r{)rR�_iZ_ax)rhr#r&rT0sz5_iLocIndexer._setitem_with_indexer.<locals>.<genexpr>css|]}|VqdS)Nr#)rR�lr#r#r&rT2sz5cannot set a frame with no defined index and a scalarN)r=)�clearrQzWcannot set using a multi-index selection indexer with a different length than the valuecsn�jj|dd�}t�t�r6t�fdd��D��r6|}n&|j�}|jj�|d�|_|jdd��jj	||�dS)NrP)r=c3s*|]"}tj|�p tj|t�j��VqdS)N)rXrsZ
is_full_slicer{r;)rRrr)r$r#r&rT�szF_iLocIndexer._setitem_with_indexer.<locals>.isetter.<locals>.<genexpr>)rbraT)r�)
r;r�rCrGrZr��_mgr�setitem�_maybe_update_cacherZ
_iset_item)r2�v�ser)�
plane_indexerr$r#r&�isetter�s

z3_iLocIndexer._setitem_with_indexer.<locals>.isetterrU)r�z?Must have equal len keys and value when setting with an ndarrayz@Must have equal len keys and value when setting with an iterablec3s$|]\}}|�krtj|�VqdS)N)rXrs)rRrhrr)�	info_axisr#r&rT�s)rbra)?�pandasr�r;Z_info_axis_numberZ_is_mixed_typer��blocksrUrCr�rI�valuesZ_can_hold_elementrGr{rnr�rrrXrsre�convert_missing_indexerrmrrfr�"convert_from_missing_indexer_tupler`rB�insertr�r�Z_is_copyrprD�_setitem_with_indexer_missingrvr�r�
_align_seriesrqr rHrWrrVrtrr[r\r�object�shape�tolistrrZr��maybe_convert_ix�_align_frameZ%_check_is_chained_assignment_possibleZ_consolidate_inplacer�)r$rbrar�Ztake_split_pathZblk�valrMZnindexerrrrL�_Zlen_non_info_axesr�rVr�r�Zitem_labelsZinfo_idxZilocs�riZlplane_indexerr�Zsub_indexer�multiindex_indexerr2�itemr�r#)rhr�r�r$r&r`�s�





*


" 



z"_iLocIndexer._setitem_with_indexercCstddlm}|jdkr�|jj}|jt|�|�}|jr\|j|d
g�}|dkj	�r\|j
||�S||g�j}t|jj�r�t|jj|g�}|jj
|||jjd�j|j_|jjdd�n�|jdk�rpt|jj�s�td��t|t�r�|j|jjdd	�}||_n\t|t��r|||jj|td
�}n:t|��r>t|�t|jj�k�r>td��|||jj|d�}|jj|�j|j_|jjdd�dS)zN
        Insert new row(s) or column(s) into the Series or DataFrame.
        r)r�rP)rVr:T)r�rQz*cannot set a frame with no defined columns)rVr�)rVr:r�z(cannot set a row with mismatched columnsNr�r�)r�r�rUr;rVr�r{r��get_indexerrmr`�_valuesrZ_constructorr:r�r�rWrfrCrr�r�r�rrp)r$rbrar�rVZ	new_indexr�Z
new_valuesr#r#r&r�s:


z*_iLocIndexer._setitem_with_indexer_missing)r�r�cCst|ttjttf�rt|g�}t|t��r�dd�}tt||��}dd�|D�}t|�}|dk}|j	dk}|j
}	|r~|o||d}||j	kr�tdd	�|D��r�|j|	j
d|dd
d�j}t|�dkr�|r�t|d�}
tj||
�j|
d�j}|Sx�t|�D]�\}}|	j
|}
t|��s"t|t��r�|�r6tj|��r6q�|
|}t|��sTt|g�}nt|�}|jj|��svt|��r�|jj�S|j|�jS|r�|j
j
d}
|jj|
��s�t|
��r�|jj�S|j|
�jSq�Wn:t|��r|j
jd�}
|jj|
��r|jj�S|j|
�jStd��d
S)aW
        Parameters
        ----------
        indexer : tuple, slice, scalar
            Indexer used to get the locations that will be set to `ser`.
        ser : pd.Series
            Values to assign to the locations specified by `indexer`.
        multiindex_indexer : boolean, optional
            Defaults to False. Should be set to True if `indexer` was from
            a `pd.MultiIndex`, to avoid unnecessary broadcasting.

        Returns
        -------
        `np.array` of `ser` broadcast to the appropriate shape for assignment
        to the locations selected by `indexer`
        cSst|tj�r|j�S|S)N)rCr[�ndarray�ravel)rhr#r#r&r�^sz)_iLocIndexer._align_series.<locals>.ravelcSsg|]}tj|��qSr#)rXrs)rRrrr#r#r&�
<listcomp>csz._iLocIndexer._align_series.<locals>.<listcomp>rPrQrcss|]}t|�VqdS)N)r)rRr�r#r#r&rTtsz-_iLocIndexer._align_series.<locals>.<genexpr>T)r�z Incompatible indexer with SeriesNr�)rCrqr[r�rIr rG�mapr�rUr;rZr�rnr�r{ZtileZreshape�TrerrXrsrrV�equalsr�rrBrf)r$rbr�r�r�ZalignersZsum_alignersZsingle_aligner�is_framer;Zlen_indexerrhrrrMZnew_ixr#r#r&r�GsR







z_iLocIndexer._align_series)�dfcCsr|jdk}t|t�r�d\}}g}xxt|�D]l\}}|jj|}	t|�sPt|t�r�t|tj	�rd|j
�}|dkrv|	|}q�|dkr�|	|}q�Pq*|j|�q*W|dk	r�|dk	r�|jj
|�r�|jj
|�r�|j�j}
n|j||d�j}
|
Sn�t|t�s�t|�o�|�rf|jj|}	|jj
|	��r"|j�j}
n@t|	t��rTt|jt��rT|	j|jjk�rTtd��|j|	d�j}
|
Std��dS)NrQ)rWzAcannot align on a multi-index with out specifying the join levels)rVz#Incompatible indexer with DataFrame)NN)rUrCrGrer;rnrrqr[r�r�rprVr�rWr�r�r�rrr�rErf)r$rbr�r�rr�colsZ	sindexersrh�ixrMr�r#r#r&r��s@



z_iLocIndexer._align_frame)F)F)r(r)r*rgr�r�rdr�r_rr�r�r�r�rurqr�rJrOr`r�rr�rr�r#r#r#r&r.+s$%
<[r.c@s0eZdZdZded�dd�Zdd�Zdd	�Zd
S)�_ScalarAccessIndexerz!
    Access scalars quickly.
    F)r?cCst|��dS)N)r
)r$rLr?r#r#r&�_convert_key�sz!_ScalarAccessIndexer._convert_keycCsDt|t�s&t|�st|g�}ntd��|j|�}|jj|d|ji�S)Nz)Invalid call for scalar access (getting)!r�)rCrGrrfr�r;r�r�)r$rLr#r#r&r'�s

z _ScalarAccessIndexer.__getitem__cs�t|t�r"t�fdd�|D��}ntj|�j�}t|t�sFt�j|�}t�j|dd��}t	|��jkrnt
d���jj||�jd��dS)Nc3s|]}tj|�j�VqdS)N)rXr]r;)rRr^)r$r#r&rT�sz3_ScalarAccessIndexer.__setitem__.<locals>.<genexpr>T)r?z0Not enough indexers for scalar access (setting)!)rar�)
rCrGrXr]r;r�rUrIr�r{rfZ
_set_valuer�)r$rLrar#)r$r&rc�s

z _ScalarAccessIndexer.__setitem__N)F)r(r)r*r+r�r�r'rcr#r#r#r&r��sr�csNeZdZdZded�dd�Zeed�dd��Z�fdd	�Z�fd
d�Z	�Z
S)
r3F)r?cCs,|jdkrt|�dkr|f}|r(t|�S|S)zd
        Require they keys to be the same type as the index. (so we don't
        fallback)
        rP)rUr{rI)r$rLr?r#r#r&r��s
z_AtIndexer._convert_key)r/cCs"|jdkst�|jjjo |jjjS)NrQ)rUrvr;rVr�rW)r$r#r#r&�_axes_are_uniquesz_AtIndexer._axes_are_uniquecsR|jdkrF|jrFt|t�s2tdd�|D��r:td��|jj|St�j	|�S)NrQcss|]}t|�VqdS)N)r)rRr^r#r#r&rTsz)_AtIndexer.__getitem__.<locals>.<genexpr>z)Invalid call for scalar access (getting)!)
rUr�rCrGrZrfr;r2�superr')r$rL)�	__class__r#r&r's
 z_AtIndexer.__getitem__csX|jdkrJ|jrJt|t�s2tdd�|D��r:td��||jj|<dSt�j	||�S)NrQcss|]}t|�VqdS)N)r)rRr^r#r#r&rT#sz)_AtIndexer.__setitem__.<locals>.<genexpr>z)Invalid call for scalar access (setting)!)
rUr�rCrGrZrfr;r2r�rc)r$rLra)r�r#r&rc s z_AtIndexer.__setitem__)F)r(r)r*r�r�r�r7r�r'rc�
__classcell__r#r#)r�r&r3�s
r3c@s eZdZdZded�dd�ZdS)r5TF)r?cCs0x*t|jj|�D]\}}t|�std��qW|S)zH
        Require integer args. (and convert to label arguments)
        z1iAt based indexing can only have integer indexers)r�r;rnrrf)r$rLr?�arhr#r#r&r�0sz_iAtIndexer._convert_keyN)F)r(r)r*r�r�r�r#r#r#r&r5,sr5.)rUr2r/cCs"dd�t|�D�}||d<t|�S)z�
    Given an indexer for the first dimension, create an equivalent tuple
    for indexing over all dimensions.

    Parameters
    ----------
    ndim : int
    loc : object

    Returns
    -------
    tuple
    cSsg|]}tdd��qS)N)rq)rRr�r#r#r&r�Isz_tuplify.<locals>.<listcomp>r)rHrG)rUr2Z_tupr#r#r&r�:sr�r!)r;c
Csf|j}t|t�r|j|dd�St|t�rb||jkr6dS|jrby
|j|�Stt	t
fk
r`dSXdS)zR
    If we are index sliceable, then return my slicer, otherwise return None.
    �getitem)r�N)rVrCrqr�rKrWr�Z_get_string_slicerFrfr�)r;rLrrr#r#r&�convert_to_index_sliceableNs



r�)rVr/cCs�|}t|t�rL|jj|�rL|j|�}t|j�}|j�r@td��|j	t
�jSt|�rdtj
|t
d�}nt|�sxt|t
d�}t||�S)aL
    Check if key is a valid boolean indexer for an object with such index and
    perform reindexing or conversion if needed.

    This function assumes that is_bool_indexer(key) == True.

    Parameters
    ----------
    index : Index
        Index of the object on which the indexing is done.
    key : list-like
        Boolean indexer to check.

    Returns
    -------
    np.array
        Resulting key.

    Raises
    ------
    IndexError
        If the key does not have the same length as index.
    IndexingError
        If the index of the key is unalignable to index.
    ztUnalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).)r�)rCrrVr�r�rr�rmr,Zastyper�rr[r�r
�pd_arrayr)rVrLr~�maskr#r#r&r�gs

r�cCs4t|t�r,|d}t|t�r$td��|dfS|dfS)z�
    Reverse convert a missing indexer, which is a dict
    return the scalar indexer and a boolean indicating if we converted
    rLz.cannot use a single bool to index into setitemTF)rCr�r�rF)rbr#r#r&r��s

r�cs&�fdd��t�fdd�t|�D��S)zK
    Create a filtered indexer that doesn't have any missing indexers.
    cs t|t�r�|j|d�S|S)NrL)rCr�rD)r��_idx)rnr#r&r��sz7convert_from_missing_indexer_tuple.<locals>.get_indexerc3s|]\}}�||�VqdS)Nr#)rRr�r�)r�r#r&rT�sz5convert_from_missing_indexer_tuple.<locals>.<genexpr>)rGre)rbrnr#)rnr�r&r��sr�cGs@d}x$|D]}t|tjtttf�s
d}q
W|r8tj|�S|SdS)z3
    We likely want to take the cross-product.
    TFN)rCr[r�rIrr Zix_)�argsZixifyr%r#r#r&r��s

r�)r/cCs<t|t�sdSx(|D] }t|�s*t|t�rt|t�SqWdS)z&
    Returns
    -------
    bool
    F)rCrGrrqr)rkr�rSr#r#r&rl�s

rlcCst|t�ot|�S)z&
    Returns
    -------
    bool
    )rCrqr)rLr#r#r&r|�sr|cCs(|jdk	p&|jdk	p&|jdk	o&|jdkS)z&
    Returns
    -------
    bool
    NrP)r�r�r�)r;r#r#r&r��s

r�csvttjtttf}t||�r*tdd�|f}td�dd��t	|�s\t|t
�sT|gg}qn|g}n�fdd�|D�}t|�S)z�
    Ensure that a slice doesn't reduce to a Series or Scalar.

    Any user-passed `subset` should have this called on it
    to make sure we're always working with DataFrames.
    N)r/cSst|t�st|�ot|t�S)z�
        Returns
        -------
        bool
            True if slice does *not* reduce,
            False if `part` is a tuple.
        )rCrqrrG)�partr#r#r&�pred�s
z!_non_reducing_slice.<locals>.predcsg|]}�|�r|n|g�qSr#r#)rRr�)r�r#r&r�	sz'_non_reducing_slice.<locals>.<listcomp>)rr[r�r rIrKrC�
IndexSlicer�rrqrG)�slice_Zkindsr#)r�r&�_non_reducing_slice�s	


rFcCs<|dkr8tjg}|r|jt�tdd�|j|d�jf}|S)z�
    Want nice defaults for background_gradient that don't break
    with non-numeric data. But if slice_ is passed go with that.
    N)�include)r[�numberrpr�r�Z
select_dtypesrW)r�rZinclude_boolZdtypesr#r#r&�_maybe_numeric_slice	s
r)F)TZtypingrrrrrZnumpyr[Zpandas._config.configrZpandas._libs.indexingrZpandas._libs.libr	Z
pandas.errorsr
rZpandas.util._decoratorsrZpandas.core.dtypes.commonr
rrrrrrrrZpandas.core.dtypes.concatrZpandas.core.dtypes.genericrrrZpandas.core.dtypes.missingrrZpandas.core.common�core�commonrXZpandas.core.constructionrr�Zpandas.core.indexersrrrZpandas.core.indexes.apir r�r!rqr}r"r��	Exceptionr,r-r8r2r1r0r.r�r4r3r6r5r�r�r�r�r�r�r�r�r�rlr|r�rrr#r#r#r&�<module>sn,
,cH(0$0
"/

'