HOME


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

���hծ�@s�dZddlmZmZddlZddlmZmZmZm	Z	m
Z
ddlZddl
mZddlmZddlmZmZmZddlmZmZmZmZdd	lmZmZdd
lmZddlm Z m!Z!m"Z"ddl#m$Z$dd
l%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddl<m=Z=m>Z>ddl?j@jAZBddlCmDZDddlEj@jFjGZHddlEmIZImJZJmKZKmLZLmMZMddlNmOZOmPZPddlQmRZRmSZSddlTmUZUddlVmWZWmXZXddlYmZZZddddhZ[e\eHj]�Z]e]j^e\dddej_d�d ��d!d"�Z`d#d$�Zad%d&�ZbGd'd(�d(�Zce e>d)e\dd*e]d+d,d-d.ej_d/�d0��eSd1d2ge=d3d4�eSd5d6d7ddd8ge=�eSd9d:d;ge=d3d<�Gd=d�deeR�����Zdedje�efd>�d?d@�Zgefd>�dAdB�ZhdEdCdD�ZidS)Fz define the IntervalIndex �)�le�ltN)�Any�List�Optional�Tuple�Union)�
get_option)�lib)�Interval�
IntervalMixin�IntervalTree)�
BaseOffset�	Timedelta�	Timestamp�	to_offset)�AnyArrayLike�Label)�InvalidIndexError)�Appender�Substitution�cache_readonly)�rewrite_exception)�find_common_type�infer_dtype_from_scalar�maybe_downcast_to_dtype)�ensure_platform_int�is_categorical_dtype�is_datetime64tz_dtype�is_datetime_or_timedelta_dtype�is_dtype_equal�is_float�is_float_dtype�
is_integer�is_integer_dtype�is_interval_dtype�is_list_like�	is_number�is_object_dtype�	is_scalar)�isna)�take_1d)�
IntervalArray�_interval_shared_docs)�is_valid_positional_slice)�Index�_index_shared_docs�default_pprint�ensure_index�maybe_extract_name)�
DatetimeIndex�
date_range)�ExtensionIndex�
inherit_names)�
MultiIndex)�TimedeltaIndex�timedelta_range)�get_op_result_name�left�rightZbothZneither�
IntervalIndexz"IntervalIndex or list of IntervalszX         name : object, optional
              Name to be stored in the index.
         )�klass�qualnameZtarget_klass�namecCs�t|dt|��}t|ttf�r"d}t|�s2t|�rB|tjdd�St	|�rR|dSt
|�rhtj|tj�St
dtt|������dS)N�dtype�
datetime64��nsz%cannot determine next label for type )�getattr�type�
isinstancerrrr�np�timedelta64r$r"�	nextafter�infty�	TypeError�repr)�labelrB�rP�>/tmp/pip-build-5_djhm0z/pandas/pandas/core/indexes/interval.py�_get_next_labelMsrRcCs�t|dt|��}t|ttf�r"d}t|�s2t|�rB|tjdd�St	|�rR|dSt
|�rjtj|tj�St
dtt|������dS)NrBrCrDrEz%cannot determine next label for type )rFrGrHrrrrrIrJr$r"rKrLrMrN)rOrBrPrPrQ�_get_prev_label[srScCs|jf|�S)zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    )�from_arrays)�cls�drPrPrQ�_new_IntervalIndexisrWc@s eZdZdZdd�Zdd�ZdS)�
SetopCheckzr
    This is called to decorate the set operations of IntervalIndex
    to perform the type check in advance.
    cCs
||_dS)N)�op_name)�selfrYrPrPrQ�__init__wszSetopCheck.__init__csd��fdd�	}|S)NFcs�|j|�t|�}t|t�sLt|jt��j�|�}�jdkrH|j|j�}|S|j	|j	kr`t
d��|jj|jjg}t|�}t
|�r�td�j�d����|||�S)N�
differencez]can only do set operations between two IntervalIndex objects that are closed on the same sidezcan only do z> between two IntervalIndex objects that have compatible dtypes)r\)Z_assert_can_do_setopr2rHr>rF�astype�objectrYrB�closed�
ValueError�subtyperr(rM)Zintvidx_self�other�sort�resultZsubtypes�common_subtype)rZ�setoprPrQ�func{s 


z!SetopCheck.__call__.<locals>.func)FrP)rZrfrgrP)rZrfrQ�__call__zszSetopCheck.__call__N)�__name__�
__module__�__qualname__�__doc__r[rhrPrPrPrQrXqsrX�classz>Immutable index of intervals that are closed on the same side.rAz0.20.0zis_overlapping
values
�aR    Examples
    --------
    A new ``IntervalIndex`` is typically constructed using
    :func:`interval_range`:

    >>> pd.interval_range(start=0, end=5)
    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
                  closed='right',
                  dtype='interval[int64]')

    It may also be constructed using one of the constructor
    methods: :meth:`IntervalIndex.from_arrays`,
    :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`.

    See further examples in the doc strings of ``interval_range`` and the
    mentioned constructor methods.
    )r?�summaryrAZversionaddedZextra_attributesZ
extra_methods�examplesZ
set_closedZ	to_tuplesT)�wrapZ	__array__�overlaps�contains�length�is_non_overlapping_monotonicZmidr_)�cachec	sneZdZUdZdgZddgZdZdZe	d�e
e
d�dd	�Zed�ee
d
�dd��Zeeed
edejd�d��d�ee
d�dd���Zeeededejd�d��d�ee
d�dd���Zeeededejd�d��d�ee
d�dd���Zeejj�dejfe
d�dd��Zedd ��Zed!d"��Ze e
d#�d$d%�Z!ee"d&�d'd(��Z#eed&�d)d*��Z$e%e
d&�d+d,��Z&d�d-d.�Z'd/d0�Z(eej)j�d�d1d2��Z)e%ed&�d3d4��Z*eej+j�d�e
e,d5�d6d7��Z+ee
d&�d8d9��Z-ed:d;��Z.e%e
d&�d<d=��Z/e
d&�d>d?�Z0d@dA�Z1eej2j�dBdC��Z2e3j4ddD�dEdF�Z5e
d&�dGdH�Z6dIdJ�Z7dKdL�Z8d�dMdN�Z9d�e:ee;e,e<e3j4fdO�dPdQ�Z=e>fee?fdRejdS�i��ee@dT�d�eAe:ee:e,e:e e3j4dU�dVdW���ZBee@dXe?�eAeCe3j4e3j4fdY�dZd[��ZDeAe3j4dY�d\d]�ZEe<ed^��fd_d`�ZFeejGj�d�dadb��ZGdcdd�ZHdedf�ZIee@dge?�d�didj��ZJd�eKeeeKedl�dmdn�ZLd��fdodp�	ZMd�dqdr�ZNdsdt�ZOed&�dudv�ZPe3j4d&�dwdx�ZQe
d&�dydz�ZReejSj�eTd{d|�d�de
dd}�d~d���ZSddd��d�d��ZUddd��d�d��ZVd�ed|�d�d��ZWe%e
d&�d�d���ZXeWd��ZYeWd��ZZeWd��Z[d�d��Z\d�d��Z]d�d��Z^d�d��Z_�Z`S)�r>Z
intervalindexrAr_TNF)�copy�verify_integritycCsBt|||�}td|j��t|||||d�}WdQRX|j||�S)Nr,)r_rwrBrx)r3rrir,�_simple_new)rU�datar_rBrwrArx�arrayrPrPrQ�__new__�s
zIntervalIndex.__new__)r{rAcCsDt|t�stt|���tj|�}||_||_i|_d|_	|j
�|S)z�
        Construct from an IntervalArray

        Parameters
        ----------
        array : IntervalArray
        name : Label, default None
            Attached as result.name
        F)rHr,�AssertionErrorrGrr|�_datarA�_cacheZ_no_setting_nameZ_reset_identity)rUr{rArdrPrPrQry�s
zIntervalIndex._simple_new�from_breaksz�        Examples
        --------
        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      closed='right',
                      dtype='interval[int64]')
        )r?rpr=)r_rwc
Cs8td|j��tj||||d�}WdQRX|j||d�S)Nr,)r_rwrB)rA)rrir,r�ry)rU�breaksr_rArwrBr{rPrPrQr��szIntervalIndex.from_breaksrTz�        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      closed='right',
                      dtype='interval[int64]')
        cCs:td|j��tj|||||d�}WdQRX|j||d�S)Nr,)rwrB)rA)rrir,rTry)rUr<r=r_rArwrBr{rPrPrQrTszIntervalIndex.from_arrays�from_tuplesz�        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       closed='right',
                       dtype='interval[int64]')
        c
Cs8td|j��tj||||d�}WdQRX|j||d�S)Nr,)r_rwrB)rA)rrir,r�ry)rUrzr_rArwrBZarrrPrPrQr�3szIntervalIndex.from_tuples)rAcCsP|tjkr|jn|}|dkr&|jj�ni}|dkr8|j}|j||d�}||_|S)N)rA)r
�
no_defaultrArrwr~ry)rZ�valuesrArvrdrPrPrQ�
_shallow_copyMszIntervalIndex._shallow_copycCs|jdkrt|j�|_|jS)z?
        Return a mask indicating if each value is NA.
        N)�_maskr*r<)rZrPrPrQ�_isnanXs
zIntervalIndex._isnancCs(|j|j�}|j|j�}t|||jd�S)N)r_)�_maybe_convert_i8r<r=r
r_)rZr<r=rPrPrQ�_engineaszIntervalIndex._engine)�key�returncCs>t|�t|t�sdSy|j|�dStk
r8dSXdS)z�
        return a boolean if this key is IN the index
        We *only* accept an Interval

        Parameters
        ----------
        key : Interval

        Returns
        -------
        bool
        FTN)�hashrHr�get_loc�KeyError)rZr�rPrPrQ�__contains__gs


zIntervalIndex.__contains__)r�cCstj|j|jgddgd�S)Nr<r=)�names)r8rTr<r=)rZrPrPrQ�_multiindex~szIntervalIndex._multiindexcCs|jS)zF
        Return the IntervalIndex's data as an IntervalArray.
        )r~)rZrPrPrQr��szIntervalIndex.valuescCsdS)NTrP)rZrPrPrQ�_has_complex_internals�sz$IntervalIndex._has_complex_internalscCs|S)NrP)rZrd�contextrPrPrQ�__array_wrap__�szIntervalIndex.__array_wrap__cCs0t|j|jd�}|j|j��tt|�|fdfS)N)r<r=)�dictr<r=�updateZ_get_attributes_dictrWrG)rZrVrPrPrQ�
__reduce__�szIntervalIndex.__reduce__cCsPtdt|�j��|jj||d�}WdQRXt|j�r@|j|�Stj|||d�S)Nr,)rw)	rrGri�_valuesr]r%rBr�r/)rZrBrwZ
new_valuesrPrPrQr]�s


zIntervalIndex.astypecCsdS)z4Return a string of the type inferred from the values�intervalrP)rZrPrPrQ�
inferred_type�szIntervalIndex.inferred_type)�deepr�cCs|jj|d�|jj|d�S)N)r�)r<�memory_usager=)rZr�rPrPrQr��szIntervalIndex.memory_usagecCs|ddd�jS)z�
        Return True if the IntervalIndex is monotonic decreasing (only equal or
        decreasing values), else False
        NrD���)�is_monotonic_increasing)rZrPrPrQ�is_monotonic_decreasing�sz%IntervalIndex.is_monotonic_decreasingcCs�|j}|j}|j�j�dkr dS|js,|jr0dSt�}tj|jdd��d}x2|D]*}||||f}||krrdS|j	|�qRWdS)zX
        Return True if the IntervalIndex contains unique elements, else False.
        rDFT)Zkeepr)
r<r=r*�sum�	is_unique�setrI�whereZ
duplicated�add)rZr<r=Z
seen_pairsZ	check_idx�idx�pairrPrPrQr��s
zIntervalIndex.is_uniquecCs|jjS)a�
        Return True if the IntervalIndex has overlapping intervals, else False.

        Two intervals overlap if they share a common point, including closed
        endpoints. Intervals that only have an open endpoint in common do not
        overlap.

        .. versionadded:: 0.24.0

        Returns
        -------
        bool
            Boolean indicating if the IntervalIndex has overlapping intervals.

        See Also
        --------
        Interval.overlaps : Check whether two Interval objects overlap.
        IntervalIndex.overlaps : Check an IntervalIndex elementwise for
            overlaps.

        Examples
        --------
        >>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)])
        >>> index
        IntervalIndex([(0, 2], (1, 3], (4, 5]],
              closed='right',
              dtype='interval[int64]')
        >>> index.is_overlapping
        True

        Intervals that share closed endpoints overlap:

        >>> index = pd.interval_range(0, 3, closed='both')
        >>> index
        IntervalIndex([[0, 1], [1, 2], [2, 3]],
              closed='both',
              dtype='interval[int64]')
        >>> index.is_overlapping
        True

        Intervals that only have an open endpoint in common do not overlap:

        >>> index = pd.interval_range(0, 3, closed='left')
        >>> index
        IntervalIndex([[0, 1), [1, 2), [2, 3)],
              closed='left',
              dtype='interval[int64]')
        >>> index.is_overlapping
        False
        )r��is_overlapping)rZrPrPrQr��s5zIntervalIndex.is_overlappingcCs|jjjdkS)N�m�M)r�r�)rBra�kind)rZrPrPrQ�_should_fallback_to_positionalsz,IntervalIndex._should_fallback_to_positionalcCst||�j|||�S)N)rF�_maybe_cast_slice_bound)rZrO�sider�rPrPrQr�sz%IntervalIndex._maybe_cast_slice_boundcCs|j|�}|dkj�rt�|S)zg
        we are passed a list-like indexer. Return the
        indexer for matching intervals.
        rDr�)�get_indexer_for�anyr�)rZZkeyarr�locsrPrPrQ�_convert_list_indexers
z#IntervalIndex._convert_list_indexer)�indexerr�cCs|jrt|�rtd��dS)z�
        Check if we are allowing reindexing with this particular indexer.

        Parameters
        ----------
        indexer : an integer indexer

        Raises
        ------
        ValueError if its a duplicate axis
        z'cannot reindex from an overlapping axisN)r��lenr`)rZr�rPrPrQ�_can_reindexs
zIntervalIndex._can_reindexcCs4t|�st|t�r|j|j�Sttttf}t||�S)a

        Check if a given key needs i8 conversion. Conversion is necessary for
        Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An
        Interval-like requires conversion if it's endpoints are one of the
        aforementioned types.

        Assumes that any list-like data has already been cast to an Index.

        Parameters
        ----------
        key : scalar or Index-like
            The key that should be checked for i8 conversion

        Returns
        -------
        bool
        )	r%rHr�_needs_i8_conversionr<rrr4r9)rZr�Zi8_typesrPrPrQr�)sz"IntervalIndex._needs_i8_conversionc
Cs�|}t|�rt|�}|j|�s"|St|�}t|�s<t|t�rr|j|j�}|j|j	�}|r\tnt
j}||||jd�S|r�t
|dd�\}}n&|jt|j�}}|jr�|j|j�}|jj}	t|	|�s�td|	�d|����|S)a
        Maybe convert a given key to it's equivalent i8 value(s). Used as a
        preprocessing step prior to IntervalTree queries (self._engine), which
        expects numeric data.

        Parameters
        ----------
        key : scalar or list-like
            The key that should maybe be converted to i8.

        Returns
        -------
        scalar or list-like
            The original key if no conversion occurred, int if converted scalar,
            Int64Index if converted list-like.
        )r_T)Zpandas_dtypez)Cannot index an IntervalIndex of subtype z with values of dtype )r&r2r�r)r%rHrr�r<r=r>rTr_rrBr/Zasi8�hasnansr�r�rar r`)
rZr��originalZscalarr<r=�constructorZ	key_dtypeZkey_i8rarPrPrQr�As*

zIntervalIndex._maybe_convert_i8cCs0|dkrdS|d	kr$td|�d���td��dS)
N�bfill�backfill�pad�ffill�nearestzmethod z& not yet implemented for IntervalIndexzInvalid fill method)r�r�r�r�r�)�NotImplementedErrorr`)rZ�methodrPrPrQ�
_check_methodwszIntervalIndex._check_methodcCs�|jstd��t|t�r td��|dkr0|jjsB|dkr\|jjr\|j}|jsR|rtt	|�}n|j}|j
sl|rtt|�}|j||�S)Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr<r=)
rur�rHrr�r<r�r=Z
open_rightrRZ	open_leftrS�_searchsorted_monotonic)rZrOr�Z
exclude_labelZsub_idxrPrPrQr��s



z%IntervalIndex._searchsorted_monotonic)r�r�c	Cs�|j|�t|�st|��t|t�rR|j|jkr8t|��|j|jk|j|jk@}nf|j	r\t
nt}|jrjt
nt}y||j|�|||j�@}Wn,t
k
r�}zt|�|�WYdd}~XnX|j�}|dkr�t|��n|dkr�|j�Stj|jd��S)a
        Get integer location, slice or boolean mask for requested label.

        Parameters
        ----------
        key : label
        method : {None}, optional
            * default: matches where the label is within an interval only.

        Returns
        -------
        int if unique index, slice if monotonic index, else mask

        Examples
        --------
        >>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
        >>> index = pd.IntervalIndex([i1, i2])
        >>> index.get_loc(1)
        0

        You can also supply a point inside an interval.

        >>> index.get_loc(1.5)
        1

        If a label is in several intervals, you get the locations of all the
        relevant intervals.

        >>> i3 = pd.Interval(0, 2)
        >>> overlapping_index = pd.IntervalIndex([i1, i2, i3])
        >>> overlapping_index.get_loc(0.5)
        array([ True, False,  True])

        Only exact matches will be returned if an interval is provided.

        >>> index.get_loc(pd.Interval(0, 1))
        0
        NrrD�u1)r�r)rrHrr_r�r<r=Zclosed_leftrrZclosed_rightrMr�Zargmaxr
Zmaybe_booleans_to_slice�view)	rZr�r��	tolerance�maskZop_leftZop_right�err�matchesrPrPrQr��s&)


zIntervalIndex.get_locZraises_sectionz�
        Raises
        ------
        NotImplementedError
            If any method argument other than the default of
            None is specified as these are not yet implemented.
        �get_indexer)�targetr��limitr�r�cCs||j|�|jrtd��t|�}t|t�r�|j|�rFtjt	|�dd�St
|jj|jjg�}|j
|j
ksnt|�r�tjtjd�t	|��S|jj|j�}|jj|j�}tj||k|d�}	n�t|j�r�|j|j�}
t|
|jdd�}	n�t|��s|j|�}|jj|j�}	ntg}	xn|D]f}y|j|�}WnFtk
�r6d	}Yn.tk
�rb}
zt|�|
�WYdd}
~
XnX|	j|��q
Wt |	�S)
NzKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_unique�intp)rBrD)�
fill_valuer�r�r�r�)!r�r�rr2rHr>�equalsrI�aranger�rrBrar_r(�repeatr�r<r�r=r�r�
categoriesr+�codesr�r�r�r�r�rM�appendr)rZr�r�r�r��target_as_indexreZleft_indexerZ
right_indexerr�Zcategories_indexerr��locr�rPrPrQr��s>






zIntervalIndex.get_indexer�get_indexer_non_unique)r�r�c	
Cs8t|�}t|t�rXt|jj|jjg�}|j|jks:t|�rXtj	dt
|��tjt
|��fSt|�slt|t��rgg}}x�t|�D]|\}}y>|j
|�}t|t�r�tj|j|j|jdd�}tj|dd�}Wn*tk
r�|j|�tjdg�}YnX|j|�q�Wtj|�}n|j|�}|jj|j�\}}t|�t|�fS)NrDr�)rB)Zndminr�r�)r2rHr>rrBrar_r(rIr�r�r��	enumerater��slice�start�stop�stepr{r�r�Zconcatenater�r�r�r�r)	rZr�r�rer��missing�ir�r�rPrPrQr�,s2







z$IntervalIndex.get_indexer_non_uniquecKs"|jr|j|�dS|j|f|�S)z�
        Guaranteed return of an indexer even when overlapping.

        This dispatches to get_indexer or get_indexer_non_unique
        as appropriate.

        Returns
        -------
        numpy.ndarray
            List of indices.
        r)r�r�r�)rZr��kwargsrPrPrQr�VszIntervalIndex.get_indexer_for)r�r�csP|jdkp|jdksBd}|dkr*t|��n|dkrBt|�sBt|��t�j||�S)NrDzClabel-based slicing with step!=1 is not supported for IntervalIndexr��getitem)r�r`r.�super�_convert_slice_indexer)rZr�r��msg)�	__class__rPrQr�fs
z$IntervalIndex._convert_slice_indexercCs0|dkr|j}tj||j|�}t|�}|j|�S)N)Z	_na_valuerIr�r�r,r�)rZZcondrbr�rdrPrPrQr�ts
zIntervalIndex.wherecCs0|jj|�}|jj|�}|jj||�}|j|�S)z�
        Return a new IntervalIndex with passed location(-s) deleted

        Returns
        -------
        IntervalIndex
        )r<�deleter=r~r�)rZr��new_left�	new_rightrdrPrPrQr�|szIntervalIndex.deletecCs�t|t�r,|j|jkrtd��|j}|j}n"t|�rFt|�rF|}}ntd��|jj||�}|jj||�}|j	j
||�}|j
|�S)a`
        Return a new IntervalIndex inserting new item at location. Follows
        Python list.append semantics for negative values.  Only Interval
        objects and NA can be inserted into an IntervalIndex

        Parameters
        ----------
        loc : int
        item : object

        Returns
        -------
        IntervalIndex
        z:inserted item must be closed on the same side as the indexz=can only insert Interval objects and NA into an IntervalIndex)rHrr_r`r<r=r)r*�insertr~r�)rZr��itemZleft_insertZright_insertr�r�rdrPrPrQr��s

zIntervalIndex.insert�takercKs&|jj|f|||d�|��}|j|�S)N)�axis�
allow_fillr�)r~r�r�)rZ�indicesr�r�r�r�rdrPrPrQr��szIntervalIndex.take�NaN)�header�na_repr�cCs|t|j|d��S)N)r�)�list�_format_native_types)rZr�r�rPrPrQ�_format_with_header�sz!IntervalIndex._format_with_headercst�jf||d�|��S)N)r��quoting)r�r�)rZr�r�r�)r�rPrQr��sz"IntervalIndex._format_native_typescs2t|�}ttd�p|dd�}t�|dkr0d}n�|dkrR�|d�}d|�d�}n�|dkr��|d�}�|d�}d|�d	|�d�}n�||kr�t|dd�}�fd
d�|d|�D�}�fdd�||d�D�}d	j|�}	d	j|�}
d|	�d
|
�d�}n(�fdd�|D�}d	j|�}d|�d�}|d|j�S)Nzdisplay.max_seq_items�
rz[]rD�[�]�z, csg|]}�|��qSrPrP)�.0�x)�	formatterrPrQ�
<listcomp>�sz.IntervalIndex._format_data.<locals>.<listcomp>csg|]}�|��qSrPrP)r�r�)r�rPrQr��sz ... csg|]}�|��qSrPrP)r�r�)r�rPrQr��s�,r�)r��minr	�str�join�
_format_space)rZrA�nZ
max_seq_itemsro�first�last�head�tailZhead_joinedZtail_joinedZjoinedrP)r�rQ�_format_data�s.


zIntervalIndex._format_datacCsJdt|j�fg}|jdk	r.|jdt|j�f�|jdd|j�d�f�|S)Nr_rArB�')rNr_rAr�r1rB)rZ�attrsrPrPrQ�
_format_attrs�s

zIntervalIndex._format_attrscCs dtt|�j�d}d|��S)N� rD�
)r�rGri)rZ�spacerPrPrQr��szIntervalIndex._format_spacecOstj|j|jf�S)N)rIZlexsortr=r<)rZ�argsr�rPrPrQ�argsort�szIntervalIndex.argsortcCsT|j|�rdSt|t�s,t|�s$dSt|�}|jj|j�oR|jj|j�oR|j|jkS)zT
        Determines if two IntervalIndex objects contain the same elements.
        TF)	�is_rHr>r%r/r<r�r=r_)rZrbrPrPrQr��s

zIntervalIndex.equals�intersection)rY)rbrcr�cCsf|jjr|jjr|j|�}n6|jjrH|jjrH|j�j�dkrH|j|�}n
|j|�}|dkrb|j�}|S)NrD)r<r�r=�_intersection_uniquer*r��_intersection_non_uniqueZsort_values)rZrbrcZtakenrPrPrQrs 
zIntervalIndex.intersection)rbr�cCsH|jj|j�}|jj|j�}||k|dk@}|j|j�d�}|j|�S)a(
        Used when the IntervalIndex does not have any common endpoint,
        no mater left or right.
        Return the intersection with another IntervalIndex.

        Parameters
        ----------
        other : IntervalIndex

        Returns
        -------
        IntervalIndex
        rDrr�)r<r�r=r�Znonzero)rZrbZlindexerZrindexer�matchr�rPrPrQrs
z"IntervalIndex._intersection_uniquecCs�tjt|�td�}|jr@|jr@tjt|��|j�d}d||<tt|j	|j
��}x.tt|j	|j
��D]\}}||krfd||<qfW||S)a
        Used when the IntervalIndex does have some common endpoints,
        on either sides.
        Return the intersection with another IntervalIndex.

        Parameters
        ----------
        other : IntervalIndex

        Returns
        -------
        IntervalIndex
        )rBrT)rI�zerosr��boolr�r�r*r��zipr<r=r�)rZrbr�Z
first_nan_locZ
other_tupsr��tuprPrPrQr.sz&IntervalIndex._intersection_non_uniquecst�d�|f�fdd�	�}|S)N)rYcsTt|j��|j|d�}t||�}|jr8|jj|jj�}n|j}t|�j	||j
|d�S)N)rc)r_rA)rFr�r;�emptyr�r]rBrarGr�r_)rZrbrcrdZresult_name)rYrPrQrgJs
z"IntervalIndex._setop.<locals>.func)rX)rYrcrgrP)rYrQ�_setopIszIntervalIndex._setopcCsdS)z�
        This is False even when left/right contain datetime-like objects,
        as the check is done on the Interval itself
        FrP)rZrPrPrQ�is_all_datesYszIntervalIndex.is_all_dates�unionr\�symmetric_differencecCstj||�S)N)r/�__lt__)rZrbrPrPrQrhszIntervalIndex.__lt__cCstj||�S)N)r/�__le__)rZrbrPrPrQrkszIntervalIndex.__le__cCstj||�S)N)r/�__gt__)rZrbrPrPrQrnszIntervalIndex.__gt__cCstj||�S)N)r/�__ge__)rZrbrPrPrQrqszIntervalIndex.__ge__)NNFNT)N)r=NFN)r=NFN)r=NFN)N)T)F)F)NN)NNN)N)rTN)r�)r�N)N)F)N)arirjrkZ_typZ_comparables�_attributesZ_defer_to_indexingr�r,r~rr|�classmethodrryrr-r��textwrap�dedentr�r�rTr�r/r�rlr
r�rr�r�rr�r8r�r��propertyr�r�r�r]r�r��intr�r�r�r�r�r�rIZndarrayr�r�r�r�r�rrr�r�r�_index_doc_kwargsr0rr�rr�r�r�r�r�r�r�rr�r�rrr�r
r�rrXrrrrrr\rrrrr�
__classcell__rPrP)r�rQr>�s�
'

	


66
A

6'

#

"
)r�cCs$tt|�t|t�t|t�|dkg�S)zJ
    Helper for interval_range to check if start/end are valid types.
    N)r�r'rHrr)�endpointrPrPrQ�_is_valid_endpointxs
r)cCsLdd�}dd�}t|�r t|�pJ||�r0||�pJ||�r@||�pJtj||�S)zK
    Helper for interval_range to check type compat of start/end/freq.
    cSst|ttf�S)N)rHrr)r�rPrPrQ�<lambda>�sz%_is_type_compatible.<locals>.<lambda>cSst|ttf�S)N)rHrr)r�rPrPrQr*�s)r'�com�any_none)�a�bZis_ts_compatZis_td_compatrPrPrQ�_is_type_compatible�sr/c
CsFtj|�}tj|�}|dk	r |n|}|dkrJtj|||�rJt|�rFdnd}tj||||�dkrftd��t|�s~td|����nt|�s�td|����t|�r�t|�}n t	|�r�|dk	r�t
d|����|dk	o�t|��ryt|�}Wn4tk
�r}ztd	|���|�WYdd}~XnXtt
||�t
||�t
||�g��sFt
d
��|dk	�rX|d7}t|��rtj|||��r�||||8}|dk�r�t|||�d}n6|dk�r�||d|}n|dk�r�||d|}tj|||�}tdd�tj|||�D���r6t|d
�}n&t|t��r"t}	nt}	|	||||d�}tj|||d�S)a�

    Return a fixed frequency IntervalIndex.

    Parameters
    ----------
    start : numeric or datetime-like, default None
        Left bound for generating intervals.
    end : numeric or datetime-like, default None
        Right bound for generating intervals.
    periods : int, default None
        Number of periods to generate.
    freq : numeric, str, or DateOffset, default None
        The length of each interval. Must be consistent with the type of start
        and end, e.g. 2 for numeric, or '5H' for datetime-like.  Default is 1
        for numeric and 'D' for datetime-like.
    name : str, default None
        Name of the resulting IntervalIndex.
    closed : {'left', 'right', 'both', 'neither'}, default 'right'
        Whether the intervals are closed on the left-side, right-side, both
        or neither.

    Returns
    -------
    IntervalIndex

    See Also
    --------
    IntervalIndex : An Index of intervals that are all closed on the same side.

    Notes
    -----
    Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
    exactly three must be specified. If ``freq`` is omitted, the resulting
    ``IntervalIndex`` will have ``periods`` linearly spaced elements between
    ``start`` and ``end``, inclusively.

    To learn more about datetime-like frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.

    Examples
    --------
    Numeric ``start`` and  ``end`` is supported.

    >>> pd.interval_range(start=0, end=5)
    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
                  closed='right', dtype='interval[int64]')

    Additionally, datetime-like input is also supported.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   end=pd.Timestamp('2017-01-04'))
    IntervalIndex([(2017-01-01, 2017-01-02], (2017-01-02, 2017-01-03],
                   (2017-01-03, 2017-01-04]],
                  closed='right', dtype='interval[datetime64[ns]]')

    The ``freq`` parameter specifies the frequency between the left and right.
    endpoints of the individual intervals within the ``IntervalIndex``.  For
    numeric ``start`` and ``end``, the frequency must also be numeric.

    >>> pd.interval_range(start=0, periods=4, freq=1.5)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
                  closed='right', dtype='interval[float64]')

    Similarly, for datetime-like ``start`` and ``end``, the frequency must be
    convertible to a DateOffset.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   periods=3, freq='MS')
    IntervalIndex([(2017-01-01, 2017-02-01], (2017-02-01, 2017-03-01],
                   (2017-03-01, 2017-04-01]],
                  closed='right', dtype='interval[datetime64[ns]]')

    Specify ``start``, ``end``, and ``periods``; the frequency is generated
    automatically (linearly spaced).

    >>> pd.interval_range(start=0, end=6, periods=4)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
              closed='right',
              dtype='interval[float64]')

    The ``closed`` parameter specifies which endpoints of the individual
    intervals within the ``IntervalIndex`` are closed.

    >>> pd.interval_range(end=5, periods=4, closed='both')
    IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
                  closed='both', dtype='interval[int64]')
    NrD�D�zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz,start must be numeric or datetime-like, got z*end must be numeric or datetime-like, got zperiods must be a number, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatiblecss|]}t|�VqdS)N)r#)r�r�rPrPrQ�	<genexpr>)sz!interval_range.<locals>.<genexpr>Zint64)r��end�periods�freq)rAr_)r+Zmaybe_box_datetimeliker,r'Zcount_not_noner`r)r!r%r#rMr�allr/Zall_not_nonerIZlinspaceZnot_nonerrHrr5r:r>r�)
r�r3r4r5rAr_r(r�r�Z
range_funcrPrPrQ�interval_range�s^Z








r7)NNNNNr=)jrl�operatorrrr"ZtypingrrrrrZnumpyrIZpandas._configr	Zpandas._libsr
Zpandas._libs.intervalrrr
Zpandas._libs.tslibsrrrrZpandas._typingrrZ
pandas.errorsrZpandas.util._decoratorsrrrZpandas.util._exceptionsrZpandas.core.dtypes.castrrrZpandas.core.dtypes.commonrrrrr r!r"r#r$r%r&r'r(r)Zpandas.core.dtypes.missingr*Zpandas.core.algorithmsr+Zpandas.core.arrays.intervalr,r-Zpandas.core.common�core�commonr+Zpandas.core.indexersr.Zpandas.core.indexes.base�indexes�baseZibaser/r0r1r2r3Zpandas.core.indexes.datetimesr4r5Zpandas.core.indexes.extensionr6r7Zpandas.core.indexes.multir8Zpandas.core.indexes.timedeltasr9r:Zpandas.core.opsr;Z
_VALID_CLOSEDr�r&r�r#rRrSrWrXr>Z_add_logical_methods_disabledrr)r/r7rPrPrPrQ�<module>s�@
'>