U
    MZf                     @  s  d Z ddlmZ ddlmZmZ ddlZddlmZm	Z	m
Z
 ddlZddlmZ ddlmZmZmZ ddlmZmZmZmZ dd	lmZmZmZmZ dd
lmZ ddlm Z m!Z! ddl"m#Z# ddl$m%Z%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z?m@Z@ ddlAmB  mCZD ddlEmFZF ddlGmB  mH  mIZJ ddlGmKZKmLZLmMZMmNZN ddlOmPZPmQZQ ddlRmSZSmTZT ddlUmVZV ddlWmXZXmYZY eZeJj[Z[e[\ddde]dd dd Z^dd  Z_d!d" Z`e e@d# dd$e[d% d&d'd(e]d)d* eTd+d,ge?d-d.eTd/d0d1d2d3d4d5d6ge?eTd7d8ge?d-d9G d:d deSZad;d<d=d>Zbd;d<d?d@ZcdGdBdCddDdEdFZddS )Hz define the IntervalIndex     )annotations)leltN)AnyHashableLiteral)lib)IntervalIntervalMixinIntervalTree)
BaseOffset	Timedelta	Timestamp	to_offset)DtypeDtypeObjIntervalClosedTypenpt)InvalidIndexError)Appendercache_readonly)rewrite_exception)find_common_typeinfer_dtype_from_scalarmaybe_box_datetimelikemaybe_downcast_numericmaybe_upcast_numeric_to_64bit)ensure_platform_int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)IntervalDtype)is_valid_na_for_dtypeunique)IntervalArray_interval_shared_docs)is_valid_positional_slice)Index_index_shared_docsensure_indexmaybe_extract_name)DatetimeIndex
date_range)ExtensionIndexinherit_names)
MultiIndex)TimedeltaIndextimedelta_rangeIntervalIndexz"IntervalIndex or list of IntervalszX         name : object, optional
              Name to be stored in the index.
         )klassqualnameZtarget_klassnamec                 C  s   t | dt| }t| ttfr"d}t|s2t|rB| tdd S t	|rR| d S t
|rht| tjS tdtt|  d S Ndtype
datetime64   nsz%cannot determine next label for type getattrtype
isinstancer   r   r   r   nptimedelta64r$   r"   Z	nextafterZinfty	TypeErrorreprlabelrA    rO   @/tmp/pip-unpacked-wheel-nbcvw55c/pandas/core/indexes/interval.py_get_next_labelp   s    rQ   c                 C  s   t | dt| }t| ttfr"d}t|s2t|rB| tdd S t	|rR| d S t
|rjt| tj S tdtt|  d S r@   rE   rM   rO   rO   rP   _get_prev_label~   s    rR   c                 C  s   | j f |S )zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    )from_arrays)clsdrO   rO   rP   _new_IntervalIndex   s    rV   classz>Immutable index of intervals that are closed on the same side.r?   z0.20.0zis_overlapping
values
 a7      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]],
                  dtype='interval[int64, right]')

    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=   summaryr?   ZversionaddedZextra_attributesZextra_methodsexamplesZ
set_closedZ	to_tuplesT)wrapZ	__array__overlapscontainsclosed_leftclosed_right	open_left
open_rightZis_emptyis_non_overlapping_monotonicclosed)cachec                	      s  e Zd ZU dZded< ded< ded< ded< ded< ded	< d
ed< d
ed< dZeZdddddd dddZe	e
ed d ededd dddddd dddZe	e
ed d ededd dddddd dd d!Ze	e
ed" d eded#d dddddd dd$d%Zed&d'd(d)Zd*dd+d,d-Zed.d'd/d0Zd1d2 Zed3d'd4d5Ze
ejjddd6d7d8d9Zedd'd:d;Zedd'd<d=Zedd'd>d?Zdd'd@dAZdBdC ZddEdFdGdHZ dId'dJdKZ!ddLdMdNdOdPdQdRdSZ"e
e#dT e$ dLdUdVdWdXZ%d dPdVdYdZZ&dLdUdVd[d\Z'edd'd]d^Z(d_Z)d`d3da fdbdcZ*edd'dddeZ+d3dFdfdgZ,dhddidjdkZ-edLd'dldmZ.edLd'dndoZ/edLd'dpdqZ0edLd'drdsZ1dtd3dtdudvdwZ2dxddyd3dzd{ fd|d}Z3dd3d'd~dZ4dd Z5d d dddZ6d d dddZ7dd'ddZ8dd Z9  Z:S )r<   Zintervalindexr   rc   boolrb   r^   r_   r`   ra   r.   _dataZ_valuesFNTzDtype | Noner   )rA   copyr?   verify_integrityreturnc              	   C  sB   t ||| }td| j t|||||d}W 5 Q R X | ||S )Nr.   )rc   rg   rA   rh   )r4   r   __name__r.   _simple_new)rT   datarc   rA   rg   r?   rh   arrayrO   rO   rP   __new__   s    	zIntervalIndex.__new__from_breakszY
             name : str, optional
                  Name of the resulting IntervalIndex.z        Examples
        --------
        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        )r=   r?   rZ   rightzIntervalClosedType | None)rc   r?   rg   rA   ri   c              	   C  s8   t d| j tj||||d}W 5 Q R X | j||dS Nr.   )rc   rg   rA   r?   )r   rj   r.   ro   rk   )rT   breaksrc   r?   rg   rA   rm   rO   rO   rP   ro      s       zIntervalIndex.from_breaksrS   z        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        c              	   C  s:   t d| j tj|||||d}W 5 Q R X | j||dS )Nr.   )rg   rA   rr   )r   rj   r.   rS   rk   )rT   leftrp   rc   r?   rg   rA   rm   rO   rO   rP   rS     s        zIntervalIndex.from_arraysfrom_tuplesz        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        c              	   C  s8   t d| j tj||||d}W 5 Q R X | j||dS rq   )r   rj   r.   ru   rk   )rT   rl   rc   r?   rg   rA   ZarrrO   rO   rP   ru   1  s    zIntervalIndex.from_tuplesr   ri   c                 C  s8   |  | j}t|}|  | j}t|}t||| jdS )Nrc   )_maybe_convert_i8rt   r   rp   r   rc   )selfrt   rp   rO   rO   rP   _engineU  s
    zIntervalIndex._enginer   )keyri   c                 C  sT   t | t|ts(t|| jr$| jS dS z| | W dS  tk
rN   Y dS X dS )z
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FTN)hashrH   r	   r+   rA   hasnansget_locKeyError)ry   r{   rO   rO   rP   __contains__^  s    

zIntervalIndex.__contains__r9   c                 C  s   t j| j| jgddgdS )Nrt   rp   )names)r9   rS   rt   rp   ry   rO   rO   rP   _multiindexw  s    zIntervalIndex._multiindexc                 C  s(   | j | j| j| jd}tt| |fd fS )N)rt   rp   rc   r?   )rt   rp   rc   r?   rV   rG   )ry   rU   rO   rO   rP   
__reduce__{  s    zIntervalIndex.__reduce__strc                 C  s   dS )z4Return a string of the type inferred from the valuesintervalrO   r   rO   rO   rP   inferred_type  s    zIntervalIndex.inferred_typeint)deepri   c                 C  s   | j j|d| jj|d S )N)r   )rt   memory_usagerp   )ry   r   rO   rO   rP   r     s    zIntervalIndex.memory_usagec                 C  s   | ddd j S )z
        Return True if the IntervalIndex is monotonic decreasing (only equal or
        decreasing values), else False
        N)is_monotonic_increasingr   rO   rO   rP   is_monotonic_decreasing  s    z%IntervalIndex.is_monotonic_decreasingc                 C  s   | j }| j}|   dkr dS |js,|jr0dS t }t|jddd }|D ],}|| || f}||krr dS |	| qPdS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        rC   FT)Zkeepr   )
rt   rp   isnasum	is_uniquesetrI   whereZ
duplicatedadd)ry   rt   rp   Z
seen_pairsZ	check_idxidxpairrO   rO   rP   r     s    zIntervalIndex.is_uniquec                 C  s   | j jS )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.

        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]],
              dtype='interval[int64, right]')
        >>> 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]],
              dtype='interval[int64, both]')
        >>> 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)],
              dtype='interval[int64, left]')
        >>> index.is_overlapping
        False
        )rz   is_overlappingr   rO   rO   rP   r     s    0zIntervalIndex.is_overlappingc                 C  s4   t |st|tr| |jS ttttf}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 its 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%   rH   r	   _needs_i8_conversionrt   r   r   r5   r:   )ry   r{   Zi8_typesrO   rO   rP   r     s    z"IntervalIndex._needs_i8_conversionc           	      C  s  t |rt|}t|}| |s&|S t|}t|s@t|trv| |j	}| |j
}|r`tntj}|||| jdS |rt|dd\}}t|r|j}qt|tr|j}qt|tjtjfr|d}n&|jt|j }}|jr||j }| jj}t||st d| d| |S )a  
        Maybe convert a given key to its 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,
            Index with an int64 dtype if converted list-like.
        rw   T)Zpandas_dtypei8z)Cannot index an IntervalIndex of subtype z with values of dtype )!r&   r3   r   r   r)   r%   rH   r	   rx   rt   rp   r<   rS   rc   r   r   Z	is_periodZordinalr   _valuerI   rB   rJ   viewrA   r1   Zasi8r}   r   Z_isnansubtyper    
ValueError)	ry   r{   Zscalarrt   rp   constructorZ	key_dtypeZkey_i8r   rO   rO   rP   rx     s@    
  

zIntervalIndex._maybe_convert_i8rt   zLiteral[('left', 'right')])sidec                 C  sz   | j stdt|ttfr$td|dkr4| jjsD|dkrZ| jjsZ| j}| j	rnt
|}n| j}| jrnt|}|||S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedrt   rp   )rb   r   rH   r
   r<   NotImplementedErrorrt   r   rp   ra   rQ   r`   rR   _searchsorted_monotonic)ry   rN   r   Zsub_idxrO   rO   rP   r   =  s$    
z%IntervalIndex._searchsorted_monotoniczint | slice | np.ndarrayc              
   C  s&  |  | t|trB| j|jkr(t|| j|jk| j|jk@ }n|t|| jrX| 	 }nf| j
rbtnt}| jrptnt}z|| j|||| j@ }W n, tk
r } zt||W 5 d}~X Y nX | }|dkrt||dkr| S t|d}t|tr"|jdkr"t|jt| |j}|S )a  
        Get integer location, slice or boolean mask for requested label.

        Parameters
        ----------
        key : label

        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
        Nr   rC   u1)Z_check_indexing_errorrH   r	   rc   r   rt   rp   r+   rA   r   r^   r   r   r_   rK   r   Zargmaxr   Zmaybe_booleans_to_slicer   slicestopstartlenstep)ry   r{   maskZop_leftZop_righterrmatchesresrO   rO   rP   r~   Z  s,    %


zIntervalIndex.get_locr1   z
str | Nonez
int | Nonez
Any | Noneznpt.NDArray[np.intp])targetmethodlimit	toleranceri   c                 C  sP   t |tr| |}n2t|js:| |}| j|j}n| 	|d S t
|S )Nr   )rH   r<   _get_indexer_unique_sidesr(   rA   rx   rz   get_indexervalues_get_indexer_pointwiser   )ry   r   r   r   r   indexerrO   rO   rP   _get_indexer  s    


zIntervalIndex._get_indexerget_indexer_non_uniquez1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r   ri   c                 C  s   t |}| |s,| |s,| j|d ddS t|trn| jjrb| jjrb| 	|}|dk
 d }q| |S n:t|js| |s| |S | |}| j|j\}}t|t|fS )NFr,   r   r   )r3   Z_should_compareZ_should_partial_indexZ_get_indexer_non_comparablerH   r<   rt   r   rp   r   nonzeror   r(   rA   rx   rz   r   r   r   )ry   r   r   missingrO   rO   rP   r     s    



z$IntervalIndex.get_indexer_non_uniquec                 C  s2   | j |j }| j|j}t||k|d}|S )zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r   )rt   r   rp   rI   r   )ry   r   Zleft_indexerZright_indexerr   rO   rO   rP   r     s    z'IntervalIndex._get_indexer_unique_sidesc              	   C  s   g g  }}t |D ]\}}zZ| |}t|trJtj|j|j|jdd}n(t	
|rdtj|dd}nt|d }W nR tk
r   || tdg}Y n* tk
r   || tdg}Y nX || qt|}t|t|fS )zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        ZintprA   rC   )Zndminr   r   )	enumerater~   rH   r   rI   aranger   r   r   r   r#   rm   r   r   appendr   Zconcatenater   )ry   r   r   r   ir{   ZlocsrO   rO   rP   r     s$    






z$IntervalIndex._get_indexer_pointwisec                 C  s   | j  o| jjdk S )N   )r   rz   Z	_na_countr   rO   rO   rP   _index_as_unique  s    zIntervalIndex._index_as_uniquezKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquer   )r{   kindc                   sN   |j d ks@|j dks@d}|dkr(t||dkr@t|s@t|t ||S )NrC   zClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)r   r   r0   super_convert_slice_indexer)ry   r{   r   msg	__class__rO   rP   r   
  s    z$IntervalIndex._convert_slice_indexerc                 C  s   | j jjdkS )N)mM)rA   r   r   r   rO   rO   rP   _should_fallback_to_positional  s    z,IntervalIndex._should_fallback_to_positionalc                 C  s   t | |||S N)rF   _maybe_cast_slice_bound)ry   rN   r   rO   rO   rP   r      s    z%IntervalIndex._maybe_cast_slice_boundr   )rA   ri   c                 C  s&   t |tsdS t| j|g}t| S )NF)rH   r*   r   rA   r(   )ry   rA   Zcommon_subtyperO   rO   rP   _is_comparable_dtype#  s    
z"IntervalIndex._is_comparable_dtypec                 C  s   t | jjddS NF)rg   )r1   rf   rt   r   rO   rO   rP   rt   +  s    zIntervalIndex.leftc                 C  s   t | jjddS r   )r1   rf   rp   r   rO   rO   rP   rp   /  s    zIntervalIndex.rightc                 C  s   t | jjddS r   )r1   rf   midr   rO   rO   rP   r   3  s    zIntervalIndex.midc                 C  s   t | jjddS r   )r1   rf   lengthr   rO   rO   rP   r   7  s    zIntervalIndex.lengthz	list[str])headerna_repri   c                 C  s   |t | j|d S )N)r   )list_format_native_types)ry   r   r   rO   rO   rP   _format_with_header?  s    z!IntervalIndex._format_with_headerNaNr   quotingznpt.NDArray[np.object_])r   ri   c                  s   t  jf ||d|S )Nr   )r   r   )ry   r   r   kwargsr   rO   rP   r   C  s    z"IntervalIndex._format_native_typesc                 C  s   | j   d|   S )N,)rf   _format_dataZ_format_space)ry   r?   rO   rO   rP   r   I  s    zIntervalIndex._format_datac                 C  sf   | j jr| jjr| |}n6|j jrH|jjrH|   dkrH|| }n
| |}|dkrb| }|S )zL
        intersection specialized to the case with matching dtypes.
        rC   N)rt   r   rp   _intersection_uniquer   r   _intersection_non_uniqueZsort_values)ry   othersortZtakenrO   rO   rP   _intersectionQ  s     
zIntervalIndex._intersection)r   ri   c                 C  sP   | j |j }| j|j}||k|dk@ }|| d }t|}| |S )a'  
        Used when the IntervalIndex does not have any common endpoint,
        no matter left or right.
        Return the intersection with another IntervalIndex.
        Parameters
        ----------
        other : IntervalIndex
        Returns
        -------
        IntervalIndex
        r   r   )rt   r   rp   Ztaker   r-   )ry   r   ZlindexerZrindexermatchr   rO   rO   rP   r   e  s    z"IntervalIndex._intersection_uniquec                 C  s   t jt| td}| jr@|jr@t t| |   d }d||< tt|j	|j
}tt| j	| j
D ]\}}||krdd||< qd| | 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
        r   r   T)rI   zerosr   re   r}   r   r   r   ziprt   rp   r   )ry   r   r   Zfirst_nan_locZ
other_tupsr   tuprO   rO   rP   r   {  s    
z&IntervalIndex._intersection_non_uniquez
np.ndarrayc                 C  s   t dd S )NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   rO   rO   rP   _get_engine_target  s    z IntervalIndex._get_engine_targetc                 C  s   t dd S )Nz,IntervalIndex does not use libjoin fastpathsr   )ry   resultrO   rO   rP   _from_join_target  s    zIntervalIndex._from_join_target)NNFNT)rp   NFN)rp   NFN)rp   NFN)F)rt   )NNN)N);rj   
__module____qualname__Z_typ__annotations__Z_can_hold_stringsr.   Z	_data_clsrn   classmethodr   r/   textwrapdedentro   rS   ru   r   rz   r   r   r   propertyr   r1   r   __doc__r   r   r   r   rx   r   r~   r   r2   _index_doc_kwargsr   r   r   r   Z_requires_unique_msgr   r   r   r   rt   rp   r   r   r   r   r   r   r   r   r   r   __classcell__rO   rO   r   rP   r<      s   
.                 	
1AF     	re   rv   c                 C  s$   t t| t| tt| t| dkgS )zJ
    Helper for interval_range to check if start/end are valid types.
    N)anyr'   rH   r   r   )endpointrO   rO   rP   _is_valid_endpoint  s    r   c                 C  sL   dd }dd }t | r t |pJ|| r0||pJ|| r@||pJt| |S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                 S  s   t | ttfS r   )rH   r   r   xrO   rO   rP   <lambda>      z%_is_type_compatible.<locals>.<lambda>c                 S  s   t | ttfS r   )rH   r   r   r   rO   rO   rP   r     r   )r'   comany_none)abZis_ts_compatZis_td_compatrO   rO   rP   _is_type_compatible  s    
r   rp   r   r   )r?   rc   ri   c           	   
   C  sL  t | } t |}| dk	r| n|}|dkrFt|| |rFt|rBdnd}t| |||dkrbtdt| sxtd|  t|std| t|rt|}nt	|s|dk	rt
d| |dk	rt|szt|}W n4 tk
r } ztd	| |W 5 d}~X Y nX tt| |t| |t||gs>t
d
|dk	rP|d7 }t|rt| ||rz|||  | 8 }|dkrt||  | d }n6| dkr||d |  } n|dkr| |d |  }t| ||}tdd t| ||D r<t|td}n.t|tr,t| |||d}nt| |||d}tj|||dS )ad  
    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, datetime.timedelta, 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]],
                  dtype='interval[int64, right]')

    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]],
                  dtype='interval[datetime64[ns], right]')

    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]],
                  dtype='interval[float64, right]')

    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]],
                  dtype='interval[datetime64[ns], right]')

    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]],
              dtype='interval[float64, right]')

    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]],
                  dtype='interval[int64, both]')
    NrC   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 zperiods must be a number, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatiblec                 s  s   | ]}t |V  qd S r   )r#   ).0r   rO   rO   rP   	<genexpr>`  s     z!interval_range.<locals>.<genexpr>Zint64)r   endperiodsfreq)r?   rc   )r   r   r   r'   Zcount_not_noner   r   r!   r   r#   rK   r   allr   Zall_not_nonerI   ZlinspaceZnot_noner   rA   rH   r   r6   r;   r<   ro   )	r   r  r  r  r?   rc   r   r   rs   rO   rO   rP   interval_range  sl    ^





r  )NNNNNrp   )er   
__future__r   operatorr   r   r   typingr   r   r   ZnumpyrI   Zpandas._libsr   Zpandas._libs.intervalr	   r
   r   Zpandas._libs.tslibsr   r   r   r   Zpandas._typingr   r   r   r   Zpandas.errorsr   Zpandas.util._decoratorsr   r   Zpandas.util._exceptionsr   Zpandas.core.dtypes.castr   r   r   r   r   Zpandas.core.dtypes.commonr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   Zpandas.core.dtypes.dtypesr*   Zpandas.core.dtypes.missingr+   Zpandas.core.algorithmsr-   Zpandas.core.arrays.intervalr.   r/   Zpandas.core.commoncorecommonr   Zpandas.core.indexersr0   Zpandas.core.indexes.baseZindexesbaseZibaser1   r2   r3   r4   Zpandas.core.indexes.datetimesr5   r6   Zpandas.core.indexes.extensionr7   r8   Zpandas.core.indexes.multir9   Zpandas.core.indexes.timedeltasr:   r;   dictr   updater   rQ   rR   rV   r<   r   r   r  rO   rO   rO   rP   <module>   s   <

     m      