a
    DBì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�rðd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ƒƒƒƒƒZed5d6œd7d8„Zfd5d6œd9d:„ZgdAd<d=dd>œd?d@„ZhdS )Bz 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ƒrP| t	 
dd¡ S t|ƒr`| d S t|ƒrvt	 | t	j¡S tdtt| ƒƒ› �ƒ‚d S ©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   ú[/mnt/bigstor/www/usecases/.venv/lib/python3.9/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ƒrP| t	 
dd¡ S t|ƒr`| d S t|ƒrxt	 | t	j ¡S tdtt| ƒƒ› �ƒ‚d S rB   rG   rQ   rS   rS   rT   Ú_get_prev_label‡   s    rV   c                 C  s   | j f i |¤ŽS )zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    )Ú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                	      sV  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d…dddddddœdd„Ze	e
ed d e d¡e d¡dœ ƒd†ddddd dœdd„ƒƒZe	e
ed d e d¡e d ¡dœ ƒd‡ddddd dœd!d"„ƒƒZe	e
ed# d e d¡e d$¡dœ ƒdˆddddd dœd%d&„ƒƒZed'd(œd)d*„ƒZd+dd,œd-d.„Zd/d d0œd1d2„Zed3d(œd4d5„ƒZd6d7„ Zed8d(œd9d:„ƒZe
ejjƒd‰dd;d<œd=d>„ƒZedd(œd?d@„ƒZedd(œdAdB„ƒZedd(œdCdD„ƒZdd(œdEdF„ZdGdH„ Z dŠdJdKœdLdM„Z!dNd(œdOdP„Z"d‹dQdRdSdTdUdVœdWdX„Z#e
e$dY e% ƒdQdZd[œd\d]„ƒZ&d dUd[œd^d_„Z'dQdZd[œd`da„Z(edd(œdbdc„ƒZ)ddZ*d/dedfœ‡ fdgdh„Z+edd(œdidj„ƒZ,d8dKœdkdl„Z-dmddnœdodp„Z.edQd(œdqdr„ƒZ/edQd(œdsdt„ƒZ0edQd(œdudv„ƒZ1edQd(œdwdx„ƒZ2dydz„ Z3d d d{œd|d}„Z4d d d{œd~d„Z5d€d(œd�d‚„Z6dƒd„„ Z7‡  Z8S )Œr>   Zintervalindexr;   rg   Úboolrf   rb   rc   rd   re   r*   Ú_dataZ_valuesFNTzIntervalClosedType | NonezDtype | NoneúHashable | Noner<   )rg   rC   ÚcopyrA   Úverify_integrityÚreturnc                 C  sV   t ||| ƒ}td| jƒ�" t|||||d�}W d   ƒ n1 s@0    Y  |  ||¡S )Nr*   )rg   rl   rC   rm   )r0   r   Ú__name__r*   Ú_simple_new)rX   Údatarg   rC   rl   rA   rm   Ú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^   Úright)rg   rA   rl   rC   rn   c                 C  sL   t d| jƒ�" tj||||d�}W d   ƒ n1 s40    Y  | j||d�S ©Nr*   )rg   rl   rC   ©rA   )r   ro   r*   rt   rp   )rX   Úbreaksrg   rA   rl   rC   rr   rS   rS   rT   rt   õ   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 s60    Y  | j||d�S )Nr*   )rl   rC   rw   )r   ro   r*   rW   rp   )rX   Úleftru   rg   rA   rl   rC   rr   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  sL   t d| jƒ�" tj||||d�}W d   ƒ n1 s40    Y  | j||d�S rv   )r   ro   r*   rz   rp   )rX   rq   rg   rA   rl   rC   ZarrrS   rS   rT   rz   <  s    0zIntervalIndex.from_tuplesr   ©rn   c                 C  s8   |   | j¡}t|ƒ}|   | j¡}t|ƒ}t||| jd�S )N©rg   )Ú_maybe_convert_i8ry   r   ru   r   rg   )Úselfry   ru   rS   rS   rT   Ú_engine`  s
    zIntervalIndex._enginer   )Úkeyrn   c                 C  sR   t |ƒ t|tƒs(t|| jƒr$| jS dS z|  |¡ W dS  tyL   Y dS 0 dS )zÏ
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FTN)ÚhashrJ   r	   r&   rC   ÚhasnansÚget_locÚKeyError)r~   r€   rS   rS   rT   Ú__contains__i  s    

zIntervalIndex.__contains__Úslice)Úslobjrn   c                 C  s   | j | }t| ƒj|| jd�S )zH
        Fastpath for __getitem__ when we know we have a slice.
        rw   )rj   rI   rp   Ú_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 )Nry   ru   )Únames)r5   rW   ry   ru   ©r~   rS   rS   rT   Ú_multiindex‰  s    zIntervalIndex._multiindexc                 C  s(   | j | j| j| jdœ}tt| ƒ|fd fS )N)ry   ru   rg   rA   )ry   ru   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Úint)Údeeprn   c                 C  s   | j j|d�| jj|d� S )N)r“   )ry   Úmemory_usageru   )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r0dS tƒ }t |jdd�¡d }|D ],}|| || f}||v rr dS | 	|¡ qPdS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        rE   FT)Zkeepr   )
ry   ru   ÚisnaÚsumÚ	is_uniqueÚsetrK   ÚwhereZ
duplicatedÚadd)r~   ry   ru   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_conversionry   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ƒsNt|tƒr„|  	|j
¡}|  	|j¡}|rntntj}|||| jd�S |rÖt|ƒ\}}t|tƒr¦|j}qüt|tƒr¸|j}qüt|tjtjfƒrü| d¡}n&|jt|jƒ }}|jrü| |j ¡}| jj}||k�r"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.
        rC   Nr|   Úi8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r   r/   r   r¡   r!   rH   rJ   r%   r	   r}   ry   ru   r>   rW   rg   r   r   Zordinalr   Ú_valuerK   Z
datetime64rL   ÚviewrC   r-   Zasi8r‚   rœ   Z_isnanÚsubtypeÚ
ValueError)	r~   r€   Zscalarr¢   ry   ru   ÚconstructorZkey_i8r¦   rS   rS   rT   r}     sB    
ÿ


ÿÿzIntervalIndex._maybe_convert_i8ry   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 supportedry   ru   )rf   r„   rJ   r
   r>   ÚNotImplementedErrorry   r–   ru   re   rU   rd   rV   Ú_searchsorted_monotonic)r~   rR   r©   Zsub_idxrS   rS   rT   r«   Q  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|  	¡ }nh| j
rbtnt}| jrptnt}z|| j|ƒ||| jƒ@ }W n. ty¾ } zt|ƒ|‚W Y d}~n
d}~0 0 | ¡ }|dkrØt|ƒ‚|dkrè| ¡ S t | d¡¡}t|tƒ�r$|jdu �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   rE   Úu1)Z_check_indexing_errorrJ   r	   rg   r„   ry   ru   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  s,    %


 zIntervalIndex.get_locr-   z
str | Nonez
int | Nonez
Any | Noneznpt.NDArray[np.intp])ÚtargetÚmethodÚlimitÚ	tolerancern   c                 C  sZ   t |tƒr|  |¡}n<t|jƒsDt|jƒsD|  |¡}| j |j	¡}n|  
|¡d S t|ƒ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_uniquez1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r´   rn   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   )r/   Z_should_compareZ_should_partial_indexZ_get_indexer_non_comparablerJ   r>   ry   rš   ru   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•   )ry   r¹   ru   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 ]¼\}}zZ|  |¡}t|tƒrJtj|j|j|jdd�}n(t	 
|¡rdtj|dd�}nt |¡d }W nN tyœ   | |¡ t dg¡}Y n( tyÂ   | |¡ t dg¡}Y n0 | |¡ 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   rr   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_uniquezLiteral['loc', 'getitem'])r€   Úkindc                   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:   )rC   rn   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  s   t | jjdd�S ©NF)rl   )r-   rj   ry   rŒ   rS   rS   rT   ry   ?  s    zIntervalIndex.leftc                 C  s   t | jjdd�S rÔ   )r-   rj   ru   rŒ   rS   rS   rT   ru   C  s    zIntervalIndex.rightc                 C  s   t | jjdd�S rÔ   )r-   rj   ÚmidrŒ   rS   rS   rT   rÕ   G  s    zIntervalIndex.midc                 C  s   t | jjdd�S rÔ   )r-   rj   ÚlengthrŒ   rS   rS   rT   rÖ   K  s    zIntervalIndex.lengthc                 C  sf   | j jr| jjr|  |¡}n6|j jrH|jjrH|  ¡  ¡ dkrH| | ¡}n
|  |¡}|du rb| ¡ }|S )zL
        intersection specialized to the case with matching dtypes.
        rE   N)ry   rš   ru   Ú_intersection_uniquer˜   r™   Ú_intersection_non_uniqueZsort_values)r~   ÚotherÚsortZtakenrS   rS   rT   Ú_intersectionR  s     
zIntervalIndex._intersection)rÙ   rn   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   )ry   r¹   ru   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 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)rK   Zzerosr¯   ri   r‚   rÃ   r˜   r›   Úzipry   ru   rÂ   )r~   rÙ   r±   Zfirst_nan_locZ
other_tupsrÅ   ÚtuprS   rS   rT   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Œ   rS   rS   rT   Ú_get_engine_target›  s    ÿz IntervalIndex._get_engine_targetc                 C  s   t dƒ‚d S )Nz,IntervalIndex does not use libjoin fastpathsrß   )r~   ÚresultrS   rS   rT   Ú_from_join_target¤  s    zIntervalIndex._from_join_target)NNFNT)ru   NFN)ru   NFN)ru   NFN)F)ry   )NNN)9ro   Ú
__module__Ú__qualname__Z_typÚ__annotations__Z_can_hold_stringsr*   Z	_data_clsrs   Úclassmethodr   r+   ÚtextwrapÚdedentrt   rW   rz   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Ó   ry   ru   rÕ   rÖ   rÛ   r×   rØ   rà   râ   Ú__classcell__rS   rS   rÎ   rT   r>       sô   
-     ùÿÿùÿÿ    úÿÿùÿÿ    ùÿÿùÿÿ    ú	
1BF   û ÿ	ri   r{   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 |ƒ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Ñ   )rJ   r   r   ©ÚxrS   rS   rT   Ú<lambda>¼  ó    z%_is_type_compatible.<locals>.<lambda>c                 S  s   t | ttfƒS 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ø   ru   rk   r;   )rA   rg   rn   c           	   
   C  s(  t | ƒ} t |ƒ}| dur| n|}|du rFt || |¡rFt|ƒrBdnd}t | |||¡dkrbtdƒ‚t| ƒsxtd| › �ƒ‚t|ƒsŽtd|› �ƒ‚t|ƒ}|durèt|ƒsèzt|ƒ}W n4 tyæ } ztd|› �ƒ|‚W Y d}~n
d}~0 0 t	t
| |ƒt
| |ƒt
||ƒgƒ�std	ƒ‚|du�r$|d7 }t|ƒ�rêt | ||¡�rVt | ||d
  |¡}nd|du �rvt||  | ƒd }n6| du �r’||d |  } n|du �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 )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>`  ró   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>   rt   )	r®   rý   rþ   rÿ   rA   rg   rî   r²   rx   rS   rS   rT   Úinterval_rangeÆ  sf    `ÿÿþýÿ




þr  )NNNNNru   )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      ú