o
    $jf                  
   @  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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+m,Z,m-Z-m.Z.m/Z/m0Z0 ddl1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z< ddl=m>  m?Z@ ddlAmBZB ddlCm>  mD  mEZF ddlCmGZGmHZHmIZImJZJ ddlKmLZLmMZM ddlNmOZOmPZP ddlQmRZR ddlSmTZTmUZU erddlVmWZW ddlXmYZYmZZZm[Z[m\Z\m]Z] e^eFj_Z_e_`dddeadd dd  Zbd!d" Zcd#d$ Zdee<d% dd&e_d' d(d)ead*d+ ePd,d-ge;d.d/ePg d0e;ePd1d2ge;d.d3G d4d deOZed@d7d8Zfd@d9d:Zg						;dAdBd>d?ZhdS )Cz define the IntervalIndex     )annotations)leltN)TYPE_CHECKINGAnyLiteral)lib)IntervalIntervalMixinIntervalTree)
BaseOffsetPeriod	Timedelta	Timestamp	to_offset)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_float_dtype
is_integeris_integer_dtypeis_list_like	is_numberis_object_dtype	is_scalaris_string_dtypepandas_dtype)DatetimeTZDtypeIntervalDtype)is_valid_na_for_dtypeunique)validate_periods)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)Hashable)DtypeDtypeObjIntervalClosedTypeSelfnpt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|}t|ds t|tr(| t	
dd S t|r0| d S t|r;t	| t	jS tdtt|  Ndtypezdatetime64[ns]mM   nsz%cannot determine next label for type getattrtype
isinstancer   r   r#   r   Zis_np_dtyper$   nptimedelta64r   r   	nextafterinf	TypeErrorreprlabelrC    rS   ]/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/pandas/core/indexes/interval.py_get_next_labelv   s   rU   c                 C  s   t | dt| }t| ttfrd}t|}t|ds t|tr(| t	
dd S t|r0| d S t|r<t	| t	j S tdtt|  rB   rG   rQ   rS   rS   rT   _get_prev_label   s   rV   c                 C  s   | j di |S )zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    NrS   )from_arrays)clsdrS   rS   rT   _new_IntervalIndex   s   rZ   classz>Immutable index of intervals that are closed on the same side.rA   z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?   summaryrA   Zextra_attributesZextra_methodsexamplesZ
set_closedZ	to_tuplesT)wrap)Z	__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					ddddZe	e
ed d ededd 				ddd d!Ze	e
ed" d eded#d 				ddd$d%Ze	e
ed& d eded'd 				ddd(d)Zedd+d,Zdd/d0Zdd3d4Zedd6d7Zd8d9 Zedd;d<Ze
ejjddd?d@ZeddAdBZeddCdDZeddEdFZddGdHZdIdJ Z dddNdOZ!ddQdRZ"			ddd\d]Z#e
e$d^ e% dd`daZ&ddbdcZ'ddddeZ(eddfdgZ)dhZ*d fdkdlZ+eddmdnZ,ddodpZ-ddrdsZ.eddtduZ/eddvdwZ0eddxdyZ1eddzd{Z2d|d} Z3dddZ4dddZ5dddZ6dd Z7  Z8S )r>   Zintervalindexr;   rg   boolrf   rb   rc   rd   re   r*   _data_valuesFNTIntervalClosedType | NonerC   Dtype | NonecopyrA   Hashable | Noneverify_integrityreturnr<   c                 C  sV   t ||| }td| j t|||||d}W d    n1 s w   Y  | ||S )Nr*   )rg   rn   rC   rp   )r0   r   __name__r*   _simple_new)rX   datarg   rC   rn   rA   rp   arrayrS   rS   rT   __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?   rA   r^   rightc                 C  L   t d| j tj||||d}W d    n1 sw   Y  | j||dS Nr*   )rg   rn   rC   rA   )r   rr   r*   rw   rs   )rX   breaksrg   rA   rn   rC   ru   rS   rS   rT   rw      s   zIntervalIndex.from_breaksrW   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  sN   t d| j tj|||||d}W d    n1 sw   Y  | j||dS )Nr*   )rn   rC   r{   )r   rr   r*   rW   rs   )rX   leftrx   rg   rA   rn   rC   ru   rS   rS   rT   rW     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  ry   rz   )r   rr   r*   r~   rs   )rX   rt   rg   rA   rn   rC   ZarrrS   rS   rT   r~   <  s   zIntervalIndex.from_tuplesr   c                 C  s8   |  | j}t|}|  | j}t|}t||| jdS )Nrg   )_maybe_convert_i8r}   r   rx   r   rg   )selfr}   rx   rS   rS   rT   _engine`  s
   zIntervalIndex._enginekeyr   c                 C  sN   t | t|tst|| jr| jS dS z| | W dS  ty&   Y dS w )z
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FT)hashrJ   r	   r&   rC   hasnansget_locKeyError)r   r   rS   rS   rT   __contains__i  s   

zIntervalIndex.__contains__slobjslicec                 C  s   | j | }t| j|| jdS )zH
        Fastpath for __getitem__ when we know we have a slice.
        r{   )rj   rI   rs   _name)r   r   resrS   rS   rT   _getitem_slice  s   
zIntervalIndex._getitem_slicer5   c                 C  s   t j| j| jgddgdS )Nr}   rx   )names)r5   rW   r}   rx   r   rS   rS   rT   _multiindex  s   zIntervalIndex._multiindexc                 C  s(   | j | j| j| jd}tt| |fd fS )N)r}   rx   rg   rA   )r}   rx   rg   rA   rZ   rI   )r   rY   rS   rS   rT   
__reduce__  s   zIntervalIndex.__reduce__strc                 C  s   dS )z4Return a string of the type inferred from the valuesintervalrS   r   rS   rS   rT   inferred_type  s   zIntervalIndex.inferred_typedeepintc                 C  s   | j j|d| jj|d S )N)r   )r}   memory_usagerx   )r   r   rS   rS   rT   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   rS   rS   rT   is_monotonic_decreasing  s   z%IntervalIndex.is_monotonic_decreasingc                 C  s   | j }| j}|   dkrdS |js|jrdS t }t|jddd }|D ]}|| || f}||v r9 dS |	| q(dS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        rE   FT)Zkeepr   )
r}   rx   isnasum	is_uniquesetrK   whereZ
duplicatedadd)r   r}   rx   Z
seen_pairsZ	check_idxidxpairrS   rS   rT   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
        )r   is_overlappingr   rS   rS   rT   r     s   0zIntervalIndex.is_overlappingc                 C  sB   t |dd}t|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
        rC   N)
rH   rJ   r%   r	   _needs_i8_conversionr}   r   r   r1   r6   )r   r   	key_dtypeZi8_typesrS   rS   rT   r     s
   
z"IntervalIndex._needs_i8_conversionc           	      C  s$  t |rt|}t|}| |s|S t|}t|dd}t|ts't|trB| 	|j
}| 	|j}|r7tntj}|||| jdS |rkt|\}}t|trS|j}n+t|tr\|j}n"t|tjtjfrj|d}n|jt|j}}|jr~||j }| jj}||krt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.
        rC   Nr   i8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r   r/   r   r   r!   rH   rJ   r%   r	   r   r}   rx   r>   rW   rg   r   r   Zordinalr   _valuerK   Z
datetime64rL   viewrC   r-   Zasi8r   r   Z_isnansubtype
ValueError)	r   r   Zscalarr   r}   rx   constructorZkey_i8r   rS   rS   rT   r     sD   



zIntervalIndex._maybe_convert_i8r}   sideLiteral['left', 'right']c                 C  sz   | j stdt|ttfrtd|dkr| jjs"|dkr-| jjs-| j}| j	r,t
|}n
| j}| jr7t|}|||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}   rx   )rf   r   rJ   r
   r>   NotImplementedErrorr}   r   rx   re   rU   rd   rV   _searchsorted_monotonic)r   rR   r   Zsub_idxrS   rS   rT   r   Q  s    z%IntervalIndex._searchsorted_monotonicint | slice | np.ndarrayc              
   C  s  |  | t|tr!| j|jkrt|| j|jk| j|jk@ }n9t|| jr,| 	 }n.| j
r1tnt}| jr8tnt}z|| j|||| j@ }W n tyY } zt||d}~ww | }|dkrft||dkrn| S t|d}t|tr|jdu rt|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   rE   u1)Z_check_indexing_errorrJ   r	   rg   r   r}   rx   r&   rC   r   rb   r   r   rc   rO   r   Zargmaxr   Zmaybe_booleans_to_slicer   r   stopstartlenstep)r   r   maskZop_leftZop_righterrmatchesr   rS   rS   rT   r   n  s0   
%


zIntervalIndex.get_loctargetr-   method
str | Nonelimit
int | None	tolerance
Any | Nonenpt.NDArray[np.intp]c                 C  s^   t |tr| |}t|S t|js(t|js(| |}| j|j	}t|S | 
|d S )Nr   )rJ   r>   _get_indexer_unique_sidesr    rC   r"   r   r   get_indexervalues_get_indexer_pointwiser   )r   r   r   r   r   indexerrS   rS   rT   _get_indexer  s   


zIntervalIndex._get_indexerget_indexer_non_unique1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c                 C  s   t |}| |s| |s| j|d ddS t|tr6| jjr1| jjr1| 	|}|dk
 d }n"| |S t|js@| |sE| |S | |}| j|j\}}t|t|fS )NFr'   r   r   )r/   Z_should_compareZ_should_partial_indexZ_get_indexer_non_comparablerJ   r>   r}   r   rx   r   nonzeror   r    rC   r   r   r   r   r   )r   r   r   missingrS   rS   rT   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   )r}   r   rx   rK   r   )r   r   Zleft_indexerZright_indexerr   rS   rS   rT   r     s   z'IntervalIndex._get_indexer_unique_sidesc              	   C  s   g g }}t |D ]^\}}z-| |}t|tr%tj|j|j|jdd}nt	
|r2tj|dd}nt|d }W n' tyN   || tdg}Y n tya   || tdg}Y nw || q	t|}t|t|fS )zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        ZintprC   rE   )Zndminr   r   )	enumerater   rJ   r   rK   aranger   r   r   r   r   ru   r   r   appendr   Zconcatenater   )r   r   r   r   ir   ZlocsrS   rS   rT   r     s(   






z$IntervalIndex._get_indexer_pointwisec                 C  s   | j  o	| jjdk S )N   )r   r   Z	_na_countr   rS   rS   rT   _index_as_unique  s   zIntervalIndex._index_as_uniquezKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquekindLiteral['loc', 'getitem']c                   sN   |j d u s |j dks d}|dkrt||dkr t|s t|t ||S )NrE   zClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)r   r   r,   super_convert_slice_indexer)r   r   r   msg	__class__rS   rT   r     s   z$IntervalIndex._convert_slice_indexerc                 C  s   | j jjdv S )NrD   )rC   r   r   r   rS   rS   rT   _should_fallback_to_positional,  s   z,IntervalIndex._should_fallback_to_positionalc                 C  s   t | |||S N)rH   _maybe_cast_slice_bound)r   rR   r   rS   rS   rT   r   4  s   z%IntervalIndex._maybe_cast_slice_boundr:   c                 C  s&   t |tsdS t| j|g}t| S )NF)rJ   r%   r   rC   r    )r   rC   Zcommon_subtyperS   rS   rT   _is_comparable_dtype7  s   

z"IntervalIndex._is_comparable_dtypec                 C     t | jjddS NF)rn   )r-   rj   r}   r   rS   rS   rT   r}   ?     zIntervalIndex.leftc                 C  r   r   )r-   rj   rx   r   rS   rS   rT   rx   C  r   zIntervalIndex.rightc                 C  r   r   )r-   rj   midr   rS   rS   rT   r   G  r   zIntervalIndex.midc                 C  r   r   )r-   rj   lengthr   rS   rS   rT   r   K  r   zIntervalIndex.lengthc                 C  sf   | j jr| jjr| |}n|j jr$|jjr$|   dkr$|| }n| |}|du r1| }|S )zL
        intersection specialized to the case with matching dtypes.
        rE   N)r}   r   rx   _intersection_uniquer   r   _intersection_non_uniqueZsort_values)r   othersortZtakenrS   rS   rT   _intersectionR  s    
zIntervalIndex._intersectionr   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   )r}   r   rx   Ztaker   r(   )r   r   ZlindexerZrindexermatchr   rS   rS   rT   r   f  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 ]\}}||v r>d||< q2| | 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)rK   Zzerosr   ri   r   r   r   r   zipr}   rx   r   )r   r   r   Zfirst_nan_locZ
other_tupsr   tuprS   rS   rT   r   |  s   z&IntervalIndex._intersection_non_unique
np.ndarrayc                 C     t d)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   rS   rS   rT   _get_engine_target  s   z IntervalIndex._get_engine_targetc                 C  r   )Nz,IntervalIndex does not use libjoin fastpathsr   )r   resultrS   rS   rT   _from_join_target  s   zIntervalIndex._from_join_target)NNFNT)rg   rl   rC   rm   rn   ri   rA   ro   rp   ri   rq   r<   )rx   NFN)
rg   rl   rA   ro   rn   ri   rC   rm   rq   r>   )
rg   r;   rA   ro   rn   ri   rC   rm   rq   r>   )rq   r   )r   r   rq   ri   )r   r   rq   r>   )rq   r5   )rq   r   )F)r   ri   rq   r   rq   ri   )r}   )r   r   )rq   r   )NNN)
r   r-   r   r   r   r   r   r   rq   r   )r   r-   rq   r   )r   r>   rq   r   )r   r   r   r   )r   r   )rC   r:   rq   ri   )rq   r-   )r   r>   rq   r>   )rq   r   )9rr   
__module____qualname__Z_typ__annotations__Z_can_hold_stringsr*   Z	_data_clsrv   classmethodr   r+   textwrapdedentrw   rW   r~   r   r   r   r   r   r   propertyr   r-   r   __doc__r   r   r   r   r   r   r   r   r.   _index_doc_kwargsr   r   r   r   Z_requires_unique_msgr   r   r   r   r}   rx   r   r   r   r   r   r   r   __classcell__rS   rS   r   rT   r>      s   
 -

	

1B
F

 




	rq   ri   c                 C  s$   t t| t| tt| t| du gS )zJ
    Helper for interval_range to check if start/end are valid types.
    N)anyr   rJ   r   r   )endpointrS   rS   rT   _is_valid_endpoint  s   r   c                 C  sL   dd }dd }t | rt |p%|| o||p%|| o||p%t| |S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                 S     t | ttfS r   )rJ   r   r   xrS   rS   rT   <lambda>      z%_is_type_compatible.<locals>.<lambda>c                 S  r   r   )rJ   r   r   r  rS   rS   rT   r    r  )r   comany_none)abZis_ts_compatZis_td_compatrS   rS   rT   _is_type_compatible  s   
r	  rx   ro   r;   c           	   
   C  s
  t | } t |}| dur| n|}|du r#t|| |r#t|r!dnd}t| |||dkr1tdt| s<td|  t|sGtd| t|}|durnt|snzt|}W n tym } ztd| |d}~ww t	t
| |t
| |t
||gstd	|dur|d7 }t|rt| ||rt| ||d
  |}n/|du rt||  | d }n| du r||d |  } n|du r| |d |  }t| ||}t	dd t| ||D rt|td}nt|trt| |||d}nt| |||d}tj|||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, Timedelta, 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 00:00:00, 2017-01-02 00:00:00],
                   (2017-01-02 00:00:00, 2017-01-03 00:00:00],
                   (2017-01-03 00:00:00, 2017-01-04 00:00:00]],
                  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 00:00:00, 2017-02-01 00:00:00],
                   (2017-02-01 00:00:00, 2017-03-01 00:00:00],
                   (2017-03-01 00:00:00, 2017-04-01 00:00:00]],
                  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]')
    NrE   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 z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatibleg?c                 s  s    | ]}t |V  qd S r   )r   ).0r  rS   rS   rT   	<genexpr>`  s    z!interval_range.<locals>.<genexpr>Zint64)r   endperiodsfreq)rA   rg   )r   r  r  r   Zcount_not_noner   r   r)   r   allr	  rO   Zall_not_nonerK   r   r   ZlinspaceZnot_noner   rC   rJ   r   r2   r7   r>   rw   )	r   r  r  r  rA   rg   r   r   r|   rS   rS   rT   interval_range  sl   `
r  r   )NNNNNrx   )rA   ro   rg   r;   rq   r>   )ir   
__future__r   operatorr   r   r   typingr   r   r   numpyrK   Zpandas._libsr   Zpandas._libs.intervalr	   r
   r   Zpandas._libs.tslibsr   r   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#   Zpandas.core.dtypes.dtypesr$   r%   Zpandas.core.dtypes.missingr&   Zpandas.core.algorithmsr(   Zpandas.core.arrays.datetimeliker)   Zpandas.core.arrays.intervalr*   r+   Zpandas.core.commoncorecommonr  Zpandas.core.indexersr,   Zpandas.core.indexes.baseZindexesbaseZibaser-   r.   r/   r0   Zpandas.core.indexes.datetimesr1   r2   Zpandas.core.indexes.extensionr3   r4   Zpandas.core.indexes.multir5   Zpandas.core.indexes.timedeltasr6   r7   collections.abcr8   Zpandas._typingr9   r:   r;   r<   r=   dictr   updater   rU   rV   rZ   r>   r   r	  r  rS   rS   rS   rT   <module>   s    0

     
c
