§
    	�’jËÊ  ã            	      óè  — d Z ddlmZ ddlmZmZ ddlmZ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%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>c m?Z@ ddlAmBZB ddlCmDZDmEZEmFZF ddlGmHZHmIZI ddlJmKZKmLZL ddlMmNZN ddlOmPZPmQZQ erddlRmSZS ddlTmUZUmVZVmWZWmXZX d„ ZYd„ ZZd„ Z[ eLddge<d ¬!¦  «         eLg d"¢e<¦  «         eLd#d$ge<d ¬%¦  «         ed&¦  «         G d'„ d(eK¦  «        ¦   «         ¦   «         ¦   «         ¦   «         Z\d2d+„Z]d2d,„Z^ ed&¦  «        	 	 	 	 	 	 d3d4d1„¦   «         Z_dS )5zdefine the IntervalIndexé    )Úannotations)ÚleÚlt)ÚTYPE_CHECKINGÚAnyÚLiteralÚSelfN)Úlib)ÚIntervalÚIntervalMixinÚIntervalTree)Ú
BaseOffsetÚPeriodÚ	TimedeltaÚ	TimestampÚ	to_offset)ÚInvalidIndexError)Úcache_readonlyÚ
set_module)Úrewrite_exception)Úfind_common_typeÚinfer_dtype_from_scalarÚmaybe_box_datetimelikeÚmaybe_downcast_numericÚmaybe_unbox_numpy_scalarÚ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)Úis_valid_positional_slice)ÚIndexÚensure_indexÚmaybe_extract_name)ÚDatetimeIndexÚ
date_range)ÚExtensionIndexÚinherit_names)Ú
MultiIndex)ÚTimedeltaIndexÚtimedelta_range)ÚHashable)ÚDtypeÚDtypeObjÚIntervalClosedTypeÚnptc                óÞ  — t          | dt          | ¦  «        ¦  «        }t          | t          t          f¦  «        rd}t          |¦  «        }t          j        |d¦  «        st          |t          ¦  «        r| t          j
        dd¦  «        z   S t          |¦  «        r| dz   S t          |¦  «        rt          j        | t          j        ¦  «        S t          dt          | ¦  «        ›�¦  «        ‚©NÚdtypezdatetime64[ns]ÚmMé   Únsz%cannot determine next label for type ©ÚgetattrÚtypeÚ
isinstancer   r   r&   r
   Úis_np_dtyper'   ÚnpÚtimedelta64r    r   Ú	nextafterÚinfÚ	TypeError©Úlabelr@   s     úJC:\Projects\DSCons\.venv\Lib\site-packages\pandas\core\indexes\interval.pyÚ_get_next_labelrQ   e   sÝ   € å�E˜7¥D¨¡K¤KÑ0Ô0€EÝ�%�)¥YÐ/Ñ0Ô0ð !Ø ˆÝ˜ÑÔ€Eå
„�u˜dÑ#Ô#ð Q¥z°%½Ñ'IÔ'Ið QØ•r”~ a¨Ñ.Ô.Ñ.Ð.Ý	˜%Ñ	 Ô	 ð QØ�q‰yÐÝ	˜Ñ	Ô	ð QÝŒ|˜E¥2¤6Ñ*Ô*Ð*åÐOÅÀUÁÄÐOÐOÑPÔPÐPó    c                óà  — t          | dt          | ¦  «        ¦  «        }t          | t          t          f¦  «        rd}t          |¦  «        }t          j        |d¦  «        st          |t          ¦  «        r| t          j
        dd¦  «        z
  S t          |¦  «        r| dz
  S t          |¦  «        r t          j        | t          j         ¦  «        S t          dt          | ¦  «        ›�¦  «        ‚r?   rD   rN   s     rP   Ú_get_prev_labelrT   v   sß   € å�E˜7¥D¨¡K¤KÑ0Ô0€EÝ�%�)¥YÐ/Ñ0Ô0ð !Ø ˆÝ˜ÑÔ€Eå
„�u˜dÑ#Ô#ð Q¥z°%½Ñ'IÔ'Ið QØ•r”~ a¨Ñ.Ô.Ñ.Ð.Ý	˜%Ñ	 Ô	 ð QØ�q‰yÐÝ	˜Ñ	Ô	ð QÝŒ|˜E¥B¤F 7Ñ+Ô+Ð+åÐOÅÀUÁÄÐOÐOÑPÔPÐPrR   c                ó   —  | j         di |¤ŽS )zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    © )Úfrom_arrays)ÚclsÚds     rP   Ú_new_IntervalIndexrZ   ‡   s   € ð
 ˆ3Œ?ÐÐ˜QÐÐÐrR   Ú
set_closedÚ	to_tuplesT)Úwrap)Ú	__array__ÚoverlapsÚcontainsÚclosed_leftÚclosed_rightÚ	open_leftÚ
open_rightÚis_emptyÚis_non_overlapping_monotonicÚclosed)ÚcacheÚpandasc                  óÀ  ‡ — e Zd ZU dZ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„Z	e
	 	 	 	 d`dad„¦   «         Ze
	 	 	 	 d`dbd„¦   «         Ze
	 	 	 	 d`dbd„¦   «         Zedcd!„¦   «         Zddd$„Zded'„Zedfd)„¦   «         Zd*„ Zedgd,„¦   «         Zdhdid/„Zedjd0„¦   «         Zedjd1„¦   «         Zedjd2„¦   «         Zdjd3„Zd4„ Zdkdld8„Zdmd:„Z	 	 	 dndodD„ZdpdF„ZdqdG„Z dpdH„Z!edjdI„¦   «         Z"dJZ#drˆ fdM„Z$edjdN„¦   «         Z%dsdO„Z&dtdQ„Z'edudR„¦   «         Z(edudS„¦   «         Z)edudT„¦   «         Z*edudU„¦   «         Z+dhdvdW„Z,dwdY„Z-dwdZ„Z.dxd\„Z/d]„ Z0ˆ xZ1S )yÚIntervalIndexaÆ	  
    Immutable index of intervals that are closed on the same side.

    Parameters
    ----------
    data : array-like (1-dimensional)
        Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) containing
        Interval objects from which to build the IntervalIndex.
    closed : {'left', 'right', 'both', 'neither'}, default 'right'
        Whether the intervals are closed on the left-side, right-side, both or
        neither.
    dtype : dtype or None, default None
        If None, dtype will be inferred.
    copy : bool, default None
        Whether to copy input data, only relevant for array, Series, and Index
        inputs (for other input, e.g. a list, a new array is created anyway).
        Defaults to True for array input and False for Index/Series.
        Set to False to avoid copying array input at your own risk (if you
        know the input data won't be modified elsewhere).
        Set to True to force copying Series/Index input up front.
    name : object, optional
         Name to be stored in the index.
    verify_integrity : bool, default True
        Verify that the IntervalIndex is valid.

    Attributes
    ----------
    left
    right
    closed
    mid
    length
    is_empty
    is_non_overlapping_monotonic
    is_overlapping
    values

    Methods
    -------
    from_arrays
    from_tuples
    from_breaks
    contains
    overlaps
    set_closed
    to_tuples

    See Also
    --------
    Index : The base pandas Index type.
    Interval : A bounded slice-like interval; the elements of an IntervalIndex.
    interval_range : Function to create a fixed frequency IntervalIndex.
    cut : Bin values into discrete Intervals.
    qcut : Bin values into equal-sized Intervals based on rank or sample quantiles.

    Notes
    -----
    See the `user guide
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`__
    for more.

    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.
    Úintervalindexr<   rg   Úboolrf   ra   rb   rc   rd   r-   Ú_dataÚ_valuesFNTúIntervalClosedType | Noner@   úDtype | NoneÚcopyúbool | NoneÚnameúHashable | NoneÚverify_integrityÚreturnr	   c                ó  — t          ||| ¦  «        }|                      |||¦  «        \  }}t          d| j        ¦  «        5  t	          |||||¬¦  «        }d d d ¦  «         n# 1 swxY w Y   |                      ||¦  «        S )Nr-   )rg   rr   r@   rv   )r1   Ú_maybe_copy_array_inputr   Ú__name__r-   Ú_simple_new)rX   Údatarg   r@   rr   rt   rv   Úarrays           rP   Ú__new__zIntervalIndex.__new__   sÒ   € õ " $¨¨cÑ2Ô2ˆð ×0Ò0°°t¸UÑCÔC‰
ˆˆdå˜°´Ñ=Ô=ð 	ð 	Ý!ØØØØØ!1ðñ ô ˆEð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð �Š˜u dÑ+Ô+Ð+s   ÁA"Á"A&Á)A&Úrightc                óº   — t          d| j        ¦  «        5  t          j        ||||¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                      ||¬¦  «        S )a\  
        Construct an IntervalIndex from an array of splits.

        Parameters
        ----------
        breaks : array-like (1-dimensional)
            Left and right bounds for each interval.
        closed : {'left', 'right', 'both', 'neither'}, default 'right'
            Whether the intervals are closed on the left-side, right-side, both
            or neither.
        name : str, optional
            Name of the resulting IntervalIndex.
        copy : bool, default False
            Copy the data.
        dtype : dtype or None, default None
            If None, dtype will be inferred.

        Returns
        -------
        IntervalIndex

        See Also
        --------
        interval_range : Function to create a fixed frequency IntervalIndex.
        IntervalIndex.from_arrays : Construct from a left and right array.
        IntervalIndex.from_tuples : Construct from a sequence of tuples.

        Examples
        --------
        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        r-   ©rg   rr   r@   N©rt   )r   rz   r-   Úfrom_breaksr{   )rX   Úbreaksrg   rt   rr   r@   r}   s          rP   rƒ   zIntervalIndex.from_breaks  s¤   € õT ˜°´Ñ=Ô=ð 	ð 	Ý!Ô-Ø˜v¨D¸ðñ ô ˆEð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð �Š˜u¨4ˆÑ0Ô0Ð0ó   –;»?Á?c                ó¼   — t          d| j        ¦  «        5  t          j        |||||¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                      ||¬¦  «        S )aH  
        Construct from two arrays defining the left and right bounds.

        Parameters
        ----------
        left : array-like (1-dimensional)
            Left bounds for each interval.
        right : array-like (1-dimensional)
            Right bounds for each interval.
        closed : {'left', 'right', 'both', 'neither'}, default 'right'
            Whether the intervals are closed on the left-side, right-side, both
            or neither.
        name : str, optional
            Name of the resulting IntervalIndex.
        copy : bool, default False
            Copy the data.
        dtype : dtype, optional
            If None, dtype will be inferred.

        Returns
        -------
        IntervalIndex

        Raises
        ------
        ValueError
            When a value is missing in only one of `left` or `right`.
            When a value in `left` is greater than the corresponding value
            in `right`.

        See Also
        --------
        interval_range : Function to create a fixed frequency IntervalIndex.
        IntervalIndex.from_breaks : Construct an IntervalIndex from an array of
            splits.
        IntervalIndex.from_tuples : Construct an IntervalIndex from an
            array-like of tuples.

        Notes
        -----
        Each element of `left` must be less than or equal to the `right`
        element at the same position. If an element is missing, it must be
        missing in both `left` and `right`. A TypeError is raised when
        using an unsupported type for `left` or `right`. At the moment,
        'category', 'object', and 'string' subtypes are not supported.

        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        r-   )rr   r@   Nr‚   )r   rz   r-   rW   r{   )rX   Úleftr   rg   rt   rr   r@   r}   s           rP   rW   zIntervalIndex.from_arraysI  s¦   € õ| ˜°´Ñ=Ô=ð 	ð 	Ý!Ô-Ø�e˜V¨$°eðñ ô ˆEð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	ð �Š˜u¨4ˆÑ0Ô0Ð0s   –<¼A ÁA c                óº   — t          d| j        ¦  «        5  t          j        ||||¬¦  «        }ddd¦  «         n# 1 swxY w Y   |                      ||¬¦  «        S )aØ  
        Construct an IntervalIndex from an array-like of tuples.

        Parameters
        ----------
        data : array-like (1-dimensional)
            Array of tuples.
        closed : {'left', 'right', 'both', 'neither'}, default 'right'
            Whether the intervals are closed on the left-side, right-side, both
            or neither.
        name : str, optional
            Name of the resulting IntervalIndex.
        copy : bool, default False
            By-default copy the data, this is compat only and ignored.
        dtype : dtype or None, default None
            If None, dtype will be inferred.

        Returns
        -------
        IntervalIndex

        See Also
        --------
        interval_range : Function to create a fixed frequency IntervalIndex.
        IntervalIndex.from_arrays : Construct an IntervalIndex from a left and
                                    right array.
        IntervalIndex.from_breaks : Construct an IntervalIndex from an array of
                                    splits.

        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        r-   r�   Nr‚   )r   rz   r-   Úfrom_tuplesr{   )rX   r|   rg   rt   rr   r@   Úarrs          rP   r‰   zIntervalIndex.from_tuples�  s­   € õX ˜°´Ñ=Ô=ð 	Yð 	YÝÔ+¨D¸ÀdÐRWÐXÑXÔXˆCð	Yð 	Yð 	Yñ 	Yô 	Yð 	Yð 	Yð 	Yð 	Yð 	Yð 	Yøøøð 	Yð 	Yð 	Yð 	Yà�Š˜s¨ˆÑ.Ô.Ð.r…   r   c                óÔ   — |                       | j        ¦  «        }t          |¦  «        }|                       | j        ¦  «        }t          |¦  «        }t	          ||| j        ¬¦  «        S )N©rg   )Ú_maybe_convert_i8r‡   r   r   r   rg   )Úselfr‡   r   s      rP   Ú_enginezIntervalIndex._engineÀ  s_   € ð ×%Ò% d¤iÑ0Ô0ˆÝ,¨TÑ2Ô2ˆØ×&Ò& t¤zÑ2Ô2ˆÝ-¨eÑ4Ô4ˆÝ˜D %°´Ð<Ñ<Ô<Ð<rR   Úkeyr   c                óØ   — t          |¦  «         t          |t          ¦  «        st          || j        ¦  «        r| j        S dS 	 |                      |¦  «         dS # t          $ r Y dS w xY w)zÏ
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FT)ÚhashrG   r   r)   r@   ÚhasnansÚget_locÚKeyError)rŽ   r�   s     rP   Ú__contains__zIntervalIndex.__contains__É  s€   € õ 	ˆS‰	Œ	ˆ	Ý˜#�xÑ(Ô(ð 	Ý$ S¨$¬*Ñ5Ô5ð $Ø”|Ð#Ø�5ð	Ø�LŠL˜ÑÔÐØ�4øÝð 	ð 	ð 	Ø�5�5ð	øøøs   ÁA Á
A)Á(A)ÚslobjÚslicec                ón   — | j         |         }t          | ¦  «                             || j        ¬¦  «        S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r‚   )rn   rF   r{   Ú_name)rŽ   r—   Úress      rP   Ú_getitem_slicezIntervalIndex._getitem_sliceâ  s1   € ð Œj˜ÔˆÝ�D‰zŒz×%Ò% c°´
Ð%Ñ;Ô;Ð;rR   r6   c                óJ   — t          j        | j        | j        gddg¬¦  «        S )Nr‡   r   )Únames)r6   rW   r‡   r   ©rŽ   s    rP   Ú_multiindexzIntervalIndex._multiindexé  s&   € åÔ% t¤y°$´*Ð&=ÀfÈgÐEVÐWÑWÔWÐWrR   c                ój   — | j         | j        | j        | j        dœ}t          t          | ¦  «        |fd fS )N)r‡   r   rg   rt   )r‡   r   rg   rt   rZ   rF   )rŽ   rY   s     rP   Ú
__reduce__zIntervalIndex.__reduce__í  s;   € à”IØ”ZØ”kØ”Ið	
ð 
ˆõ "¥D¨¡J¤J° ?°DÐ8Ð8rR   Ústrc                ó   — dS )z4Return a string of the type inferred from the valuesÚintervalrV   rŸ   s    rP   Úinferred_typezIntervalIndex.inferred_typeö  s	   € ð ˆzrR   ÚdeepÚintc                óp   — | j                              |¬¦  «        | j                             |¬¦  «        z   S )a  
        Memory usage of the values.

        Parameters
        ----------
        deep : bool, default False
            Introspect the data deeply, interrogate
            `object` dtypes for system-level memory consumption.

        Returns
        -------
        bytes used
            Returns memory usage of the values in the Index in bytes.

        See Also
        --------
        numpy.ndarray.nbytes : Total bytes consumed by the elements of the
            array.

        Notes
        -----
        Memory usage does not include memory consumed by elements that
        are not components of the array if deep=False or if used on PyPy

        Examples
        --------
        >>> idx = pd.Index([1, 2, 3])
        >>> idx.memory_usage()
        24
        )r§   )r‡   Úmemory_usager   )rŽ   r§   s     rP   rª   zIntervalIndex.memory_usageû  s7   € ðB Œy×%Ò%¨4Ð%Ñ0Ô0°4´:×3JÒ3JÐPTÐ3JÑ3UÔ3UÑUÐUrR   c                ó"   — | 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Ÿ   s    rP   Úis_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing   s   € ð �D�D�b�DŒzÔ1Ð1rR   c                ót  — | j         }| j        }|                      ¦   «                              ¦   «         dk    rdS |j        s|j        rdS t          ¦   «         }t          j        |                     d¬¦  «        ¦  «        d         }|D ].}||         ||         f}||v r dS | 	                    |¦  «         Œ/dS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        rB   FT)Úkeepr   )
r‡   r   ÚisnaÚsumÚ	is_uniqueÚsetrI   ÚwhereÚ
duplicatedÚadd)rŽ   r‡   r   Ú
seen_pairsÚ	check_idxÚidxÚpairs          rP   r³   zIntervalIndex.is_unique(  sÄ   € ð
 ŒyˆØ”
ˆà�9Š9‰;Œ;�?Š?ÑÔ˜qÒ Ð Ø�5àŒ>ð 	˜Uœ_ð 	Ø�4å‘U”Uˆ
Ý”H˜TŸ_š_°%˜_Ñ8Ô8Ñ9Ô9¸!Ô<ˆ	Øð 	!ð 	!ˆCØ˜”I˜u SœzÐ*ˆDØ�zÐ!Ð!Ø�u�uØ�NŠN˜4Ñ Ô Ð Ð àˆtrR   c                ó   — | 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Ÿ   s    rP   r½   zIntervalIndex.is_overlapping@  s   € ð` Œ|Ô*Ð*rR   c                ó   — 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
        r@   N)
rE   rG   r(   r   Ú_needs_i8_conversionr‡   r   r   r2   r7   )rŽ   r�   Ú	key_dtypeÚi8_typess       rP   r¿   z"IntervalIndex._needs_i8_conversionr  sl   € õ$ ˜C ¨$Ñ/Ô/ˆ	Ý�i¥Ñ/Ô/ð 	7µ:¸cÅ8Ñ3LÔ3Lð 	7Ø×,Ò,¨S¬XÑ6Ô6Ð6å�y­-½ÐHˆÝ˜#˜xÑ(Ô(Ð(rR   c                óº  — t          |¦  «        rt          |¦  «        }t          |¦  «        }|                      |¦  «        s|S t	          |¦  «        }t          |dd¦  «        }t          |t          ¦  «        st          |t          ¦  «        r\|  	                    |j
        ¦  «        }|  	                    |j        ¦  «        }|rt          nt          j        } |||| j        ¬¦  «        S |rˆt          |¦  «        \  }}t          |t           ¦  «        r|j        }n˜t          |t$          ¦  «        r|j        }n{t          |t(          j        t(          j        f¦  «        r|                     d¦  «        }n?|j        t3          |j        d¬¦  «        }}|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.
        r@   NrŒ   Úi8F©rr   z)Cannot index an IntervalIndex of subtype z with values of dtype ) r!   r0   r   r¿   r$   rE   rG   r(   r   r�   r‡   r   rk   rW   rg   r   r   Úordinalr   Ú_valuerI   Ú
datetime64rJ   Úviewr@   r/   Úasi8r“   rµ   Ú_isnanÚsubtypeÚ
ValueError)	rŽ   r�   ÚscalarrÀ   r‡   r   ÚconstructorÚkey_i8rË   s	            rP   r�   zIntervalIndex._maybe_convert_i8‹  sæ  € õ" ˜ÑÔð 	5Ý˜sÑ#Ô#ˆCÝ/°Ñ4Ô4ˆCà×(Ò(¨Ñ-Ô-ð 	ØˆJå˜3‘”ˆÝ˜C ¨$Ñ/Ô/ˆ	Ý�i¥Ñ/Ô/ð 	@µ:¸cÅ8Ñ3LÔ3Lð 	@à×)Ò)¨#¬(Ñ3Ô3ˆDØ×*Ò*¨3¬9Ñ5Ô5ˆEØ&,ÐK�(˜(µ-Ô2KˆKØ�;˜t U°4´;Ð?Ñ?Ô?Ð?àð 	3å 7¸Ñ <Ô <ÑˆI�vÝ˜#�vÑ&Ô&ð +Øœ��Ý˜F¥IÑ.Ô.ð +Øœ��Ý˜F¥R¤]µB´NÐ$CÑDÔDð +ØŸš TÑ*Ô*�øð !$¤	­5°´ÀÐ+FÑ+FÔ+F�vˆIØŒ{ð 3ð  Ÿš s¤z kÑ2Ô2�ð
 ”*Ô$ˆà�iÒÐÝð/¸Gð /ð /Ø#,ð/ð /ñô ð ð
 ˆrR   r‡   ÚsideúLiteral['left', 'right']c                ón  — | 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        rt          |¦  «        }|                     ||¦  «        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   )rf   r•   rG   r   rk   ÚNotImplementedErrorr‡   r­   r   rd   rQ   rc   rT   Ú_searchsorted_monotonic)rŽ   rO   rÐ   Úsub_idxs       rP   rÔ   z%IntervalIndex._searchsorted_monotonicÊ  sÇ   € ØÔ0ð 	ÝðMñô ð õ
 �e�m­]Ð;Ñ<Ô<ð 	VÝ%Ð&TÑUÔUÐUð
 �FŠNˆN˜tœyÔ@ˆNØ�GŠOˆO D¤IÔ$EˆOà”jˆGØŒð /Ý'¨Ñ.Ô.�øà”iˆGØŒ~ð /Ý'¨Ñ.Ô.�à×.Ò.¨u°dÑ;Ô;Ð;rR   úint | slice | np.ndarrayc                óˆ  — |                       |¦  «         t          |t          ¦  «        rA| j        |j        k    rt	          |¦  «        ‚| j        |j        k    | j        |j        k    z  }n›t          || j        ¦  «        r|  	                    ¦   «         }nq| j
        rt          nt          }| j        rt          nt          }	  || j        |¦  «         ||| j        ¦  «        z  }n"# t          $ r}t	          |¦  «        |‚d}~ww xY w|                     ¦   «         }|dk    rt	          |¦  «        ‚|dk    r!t!          |                     ¦   «         ¦  «        S t%          j        |                     d¦  «        ¦  «        }t          |t*          ¦  «        r/|j        €(t+          |j        t1          | ¦  «        |j        ¦  «        }|S )a6  
        Get integer location, slice or boolean mask for requested label.

        The `get_loc` method is used to retrieve the integer index, a slice for
        slicing objects, or a boolean mask indicating the presence of the label
        in the `IntervalIndex`.

        Parameters
        ----------
        key : label
            The value or range to find in the IntervalIndex.

        Returns
        -------
        int if unique index, slice if monotonic index, else mask
            The position or positions found. This could be a single
            number, a range, or an array of true/false values
            indicating the position(s) of the label.

        See Also
        --------
        IntervalIndex.get_indexer_non_unique : Compute indexer and
            mask for new index given the current index.
        Index.get_loc : Similar method in the base Index class.

        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   rB   Úu1)Ú_check_indexing_errorrG   r   rg   r•   r‡   r   r)   r@   r±   ra   r   r   rb   rM   r²   r   Úargmaxr
   Úmaybe_booleans_to_slicerÈ   r˜   ÚstopÚstartÚlenÚstep)rŽ   r�   ÚmaskÚop_leftÚop_rightÚerrÚmatchesr›   s           rP   r”   zIntervalIndex.get_locç  s›  € ðf 	×"Ò" 3Ñ'Ô'Ð'å�c�8Ñ$Ô$ð 	-ØŒ{˜cœjÒ(Ð(Ý˜s‘m”mÐ#Ø”I ¤Ò)¨d¬j¸C¼IÒ.EÑFˆDˆDÝ" 3¨¬
Ñ3Ô3ð 
	-Ø—9’9‘;”;ˆDˆDð !Ô,Ð4•b�bµ"ˆGØ!Ô.Ð6•r�rµBˆHð-Ø�w˜tœy¨#Ñ.Ô.°°¸#¸t¼zÑ1JÔ1JÑJ��øÝð -ð -ð -å˜s‘m”m¨Ð,øøøøð-øøøð —(’(‘*”*ˆØ�aŠ<ˆ<Ý˜3‘-”-ÐØ�aŠ<ˆ<Ý+¨D¯KªK©M¬MÑ:Ô:Ð:åÔ)¨$¯)ª)°D©/¬/Ñ:Ô:ˆÝ�c�5Ñ!Ô!ð 	8 c¤hÐ&6å˜œ	¥3 t¡9¤9¨c¬hÑ7Ô7ˆCØˆ
s   Ã#C% Ã%
DÃ/C?Ã?DÚtargetr/   Úmethodú
str | NoneÚlimitú
int | NoneÚ	toleranceú
Any | Noneúnpt.NDArray[np.intp]c                óÎ  — t          |t          ¦  «        rJ| j        j        r"| j        j        r|                      |¦  «        }n”|                      |¦  «        d         }nxt          |j        ¦  «        sIt          |j        ¦  «        s5|  
                    |¦  «        }| j                             |j        ¦  «        }n|                      |¦  «        d         S t          |¦  «        S )Nr   )rG   rk   r‡   r³   r   Ú_get_indexer_unique_sidesÚ_get_indexer_pointwiser#   r@   r%   r�   r�   Úget_indexerÚvaluesr   )rŽ   rå   ræ   rè   rê   Úindexers         rP   Ú_get_indexerzIntervalIndex._get_indexer8  sÜ   € õ �f�mÑ,Ô,ð 	:ð
 ŒyÔ"ð A t¤zÔ';ð AØ×8Ò8¸Ñ@Ô@��à×5Ò5°fÑ=Ô=¸aÔ@��å! &¤,Ñ/Ô/ð 	:µ?À6Ä<Ñ3PÔ3Pð 	:ð ×+Ò+¨FÑ3Ô3ˆFØ”l×.Ò.¨v¬}Ñ=Ô=ˆGˆGð ×.Ò.¨vÑ6Ô6°qÔ9Ð9å" 7Ñ+Ô+Ð+rR   ú1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c                ó¶  — t          |¦  «        }|                      |¦  «        s-|                      |¦  «        s|                      |dd¬¦  «        S t	          |t
          ¦  «        ra| j        j        r@| j        j        r4|  	                    |¦  «        }|dk     
                    ¦   «         d         }nŠ|                      |¦  «        S t          |j        ¦  «        s|                      |¦  «        s|                      |¦  «        S |                      |¦  «        }| j                             |j        ¦  «        \  }}t%          |¦  «        t%          |¦  «        fS )aq  
        Compute indexer and mask for new index given the current index.

        The indexer should be then used as an input to ndarray.take to align the
        current data to the new index.

        Parameters
        ----------
        target : IntervalIndex or list of Intervals
            An iterable containing the values to be used for computing indexer.

        Returns
        -------
        indexer : np.ndarray[np.intp]
            Integers from 0 to n - 1 indicating that the index at these
            positions matches the corresponding target values. Missing values
            in the target are marked by -1.
        missing : np.ndarray[np.intp]
            An indexer into the target of the values not found.
            These correspond to the -1 in the indexer array.

        See Also
        --------
        Index.get_indexer : Computes indexer and mask for new index given
            the current index.
        Index.get_indexer_for : Returns an indexer even when non-unique.

        Examples
        --------
        >>> index = pd.Index(["c", "b", "a", "b", "b"])
        >>> index.get_indexer_non_unique(["b", "b"])
        (array([1, 3, 4, 1, 3, 4]), array([], dtype=int64))

        In the example below there are no matched values.

        >>> index = pd.Index(["c", "b", "a", "b", "b"])
        >>> index.get_indexer_non_unique(["q", "r", "t"])
        (array([-1, -1, -1]), array([0, 1, 2]))

        For this reason, the returned ``indexer`` contains only integers equal to -1.
        It demonstrates that there's no match between the index and the ``target``
        values at these positions. The mask [0, 1, 2] in the return value shows that
        the first, second, and third elements are missing.

        Notice that the return value is a tuple contains two items. In the example
        below the first item is an array of locations in ``index``. The second
        item is a mask shows that the first and third elements are missing.

        >>> index = pd.Index(["c", "b", "a", "b", "b"])
        >>> index.get_indexer_non_unique(["f", "b", "s"])
        (array([-1,  1,  3,  4, -1]), array([0, 2]))
        NFr*   r¬   r   )r0   Ú_should_compareÚ_should_partial_indexÚ_get_indexer_non_comparablerG   rk   r‡   r³   r   rî   Únonzerorï   r#   r@   r�   r�   Úget_indexer_non_uniquerñ   r   )rŽ   rå   rò   Úmissings       rP   rú   z$IntervalIndex.get_indexer_non_uniqueU  sU  € õn ˜fÑ%Ô%ˆà×#Ò# FÑ+Ô+ð 	R°D×4NÒ4NÈvÑ4VÔ4Vð 	Rð ×3Ò3°F¸DÈÐ3ÑOÔOÐOå˜¥Ñ.Ô.ð 	RØŒyÔ"ð ; t¤zÔ';ð ;à×8Ò8¸Ñ@Ô@�Ø" bš=×1Ò1Ñ3Ô3°AÔ6��à×2Ò2°6Ñ:Ô:Ð:å˜Vœ\Ñ*Ô*ð 	R°$×2LÒ2LÈVÑ2TÔ2Tð 	Rà×.Ò.¨vÑ6Ô6Ð6ð
 ×+Ò+¨FÑ3Ô3ˆFØ#œ|×BÒBÀ6Ä=ÑQÔQÑˆG�Wå" 7Ñ+Ô+Õ-@ÀÑ-IÔ-IÐIÐIrR   c                ó¶   — | j                              |j         ¦  «        }| j                             |j        ¦  «        }t          j        ||k    |d¦  «        }|S )zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r¬   )r‡   rð   r   rI   rµ   )rŽ   rå   Úleft_indexerÚright_indexerrò   s        rP   rî   z'IntervalIndex._get_indexer_unique_sides§  sO   € ð ”y×,Ò,¨V¬[Ñ9Ô9ˆØœ
×.Ò.¨v¬|Ñ<Ô<ˆÝ”(˜<¨=Ò8¸,ÈÑKÔKˆØˆrR   c                óÖ  — g g }}t          |¦  «        D �]#\  }}	 |                      |¦  «        }t          |t          ¦  «        r(t	          j        |j        |j        |j        d¬¦  «        }nEt          j
        |¦  «        rt	          j        |d¬¦  «        }nt	          j        |¦  «        d         }no# t          $ r- |                     |¦  «         t	          j        dg¦  «        }Y n9t          $ r- |                     |¦  «         t	          j        dg¦  «        }Y nw xY w|                     |¦  «         �Œ%t	          j        |¦  «        }t#          |¦  «        t#          |¦  «        fS )zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        Úintp©r@   rB   )Úndminr   r¬   )Ú	enumerater”   rG   r˜   rI   ÚarangerÝ   rÜ   rß   r
   r   r}   rµ   r•   Úappendr   Úconcatenater   )rŽ   rå   rò   rû   Úir�   ÚlocsÚconcatenated_indexers           rP   rï   z$IntervalIndex._get_indexer_pointwise³  sj  € ð ˜r�ˆÝ Ñ'Ô'ð 	!ñ 	!‰FˆAˆsð&Ø—|’| CÑ(Ô(�Ý˜d¥EÑ*Ô*ð -åœ9 T¤Z°´¸D¼IÈVÐTÑTÔT�D�DÝ”^ DÑ)Ô)ð -Ýœ8 D°Ð2Ñ2Ô2�D�Dõ œ8 D™>œ>¨!Ô,�DøøÝð &ð &ð &Ø—’˜qÑ!Ô!Ð!Ý”x  ‘~”~���Ý$ð &ð &ð &ð —’˜qÑ!Ô!Ð!Ý”x  ‘~”~���ð	&øøøð �NŠN˜4Ñ Ô Ð Ñ å!œ~¨gÑ6Ô6ÐÝ"Ð#7Ñ8Ô8Õ:MÈgÑ:VÔ:VÐVÐVs   ›BB3Â34DÃ)3DÄDc                ó2   — | j          o| j        j        dk     S )Né   )r½   r�   Ú	_na_countrŸ   s    rP   Ú_index_as_uniquezIntervalIndex._index_as_uniqueÓ  s   € àÔ&Ð&ÐE¨4¬<Ô+AÀAÒ+EÐErR   zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniqueÚkindúLiteral['loc', 'getitem']c                óâ   •— |j         �F|j         dk    s;d}|dk    rt          |¦  «        ‚|dk    rt          |¦  «        st          |¦  «        ‚t          ¦   «                              ||¦  «        S )NrB   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__s       €rP   r  z$IntervalIndex._convert_slice_indexerÛ  ss   ø€ Ø”Ð  C¤H°¢M Mð XˆCØ�uŠ}ˆ}Ý  ‘o”oÐ%Ø�yÒ Ð Ý0°Ñ5Ô5ð *å$ S™/œ/Ð)å‰wŒw×-Ò-¨c°4Ñ8Ô8Ð8rR   c                ó(   — | j         j        j        dv S )NrA   )r@   rË   r  rŸ   s    rP   Ú_should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positionalé  s   € ð ŒzÔ!Ô&¨$Ð.Ð.rR   c                óJ   — t          | |¦  «                             ||¦  «        S ©N)rE   Ú_maybe_cast_slice_bound)rŽ   rO   rÐ   s      rP   r  z%IntervalIndex._maybe_cast_slice_boundñ  s"   € Ý�t˜TÑ"Ô"×:Ò:¸5À$ÑGÔGÐGrR   r;   c                ó|   — t          |t          ¦  «        sdS t          | j        |g¦  «        }t	          |¦  «         S )NF)rG   r(   r   r@   r#   )rŽ   r@   Úcommon_subtypes      rP   Ú_is_comparable_dtypez"IntervalIndex._is_comparable_dtypeô  s>   € Ý˜%¥Ñ/Ô/ð 	Ø�5Ý)¨4¬:°uÐ*=Ñ>Ô>ˆÝ" >Ñ2Ô2Ð2Ð2rR   c                ó8   — t          | j        j        d¬¦  «        S )aM  
        Return left bounds of the intervals in the IntervalIndex.

        The left bounds of each interval in the IntervalIndex are
        returned as an Index. The datatype of the left bounds is the
        same as the datatype of the endpoints of the intervals.

        Returns
        -------
        Index
            An Index containing the left bounds of the intervals.

        See Also
        --------
        IntervalIndex.right : Return the right bounds of the intervals
            in the IntervalIndex.
        IntervalIndex.mid : Return the mid-point of the intervals in
            the IntervalIndex.
        IntervalIndex.length : Return the length of the intervals in
            the IntervalIndex.

        Examples
        --------
        >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right")
        >>> iv_idx.left
        Index([1, 2, 3], dtype='int64')

        >>> iv_idx = pd.IntervalIndex.from_tuples(
        ...     [(1, 4), (2, 5), (3, 6)], closed="left"
        ... )
        >>> iv_idx.left
        Index([1, 2, 3], dtype='int64')
        FrÄ   )r/   rn   r‡   rŸ   s    rP   r‡   zIntervalIndex.leftü  s   € õF �T”Z”_¨5Ð1Ñ1Ô1Ð1rR   c                ó8   — t          | j        j        d¬¦  «        S )aQ  
        Return right bounds of the intervals in the IntervalIndex.

        The right bounds of each interval in the IntervalIndex are
        returned as an Index. The datatype of the right bounds is the
        same as the datatype of the endpoints of the intervals.

        Returns
        -------
        Index
            An Index containing the right bounds of the intervals.

        See Also
        --------
        IntervalIndex.left : Return the left bounds of the intervals
            in the IntervalIndex.
        IntervalIndex.mid : Return the mid-point of the intervals in
            the IntervalIndex.
        IntervalIndex.length : Return the length of the intervals in
            the IntervalIndex.

        Examples
        --------
        >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6], closed="right")
        >>> iv_idx.right
        Index([4, 5, 6], dtype='int64')

        >>> iv_idx = pd.IntervalIndex.from_tuples(
        ...     [(1, 4), (2, 5), (3, 6)], closed="left"
        ... )
        >>> iv_idx.right
        Index([4, 5, 6], dtype='int64')
        FrÄ   )r/   rn   r   rŸ   s    rP   r   zIntervalIndex.right!  s   € õF �T”ZÔ%¨EÐ2Ñ2Ô2Ð2rR   c                ó8   — t          | j        j        d¬¦  «        S )ae  
        Return the midpoint of each interval in the IntervalIndex as an Index.

        Each midpoint is calculated as the average of the left and right bounds
        of each interval. The midpoints are returned as a pandas Index object.

        Returns
        -------
        pandas.Index
            An Index containing the midpoints of each interval.

        See Also
        --------
        IntervalIndex.left : Return the left bounds of the intervals
            in the IntervalIndex.
        IntervalIndex.right : Return the right bounds of the intervals
            in the IntervalIndex.
        IntervalIndex.length : Return the length of the intervals in
            the IntervalIndex.

        Notes
        -----
        The midpoint is the average of the interval bounds, potentially resulting
        in a floating-point number even if bounds are integers. The returned Index
        will have a dtype that accurately holds the midpoints. This computation is
        the same regardless of whether intervals are open or closed.

        Examples
        --------
        >>> iv_idx = pd.IntervalIndex.from_arrays([1, 2, 3], [4, 5, 6])
        >>> iv_idx.mid
        Index([2.5, 3.5, 4.5], dtype='float64')

        >>> iv_idx = pd.IntervalIndex.from_tuples([(1, 4), (2, 5), (3, 6)])
        >>> iv_idx.mid
        Index([2.5, 3.5, 4.5], dtype='float64')
        FrÄ   )r/   rn   ÚmidrŸ   s    rP   r"  zIntervalIndex.midF  s   € õN �T”Z”^¨%Ð0Ñ0Ô0Ð0rR   c                ó8   — t          | j        j        d¬¦  «        S )a`  
        Calculate the length of each interval in the IntervalIndex.

        This method returns a new Index containing the lengths of each interval
        in the IntervalIndex. The length of an interval is defined as the difference
        between its end and its start.

        Returns
        -------
        Index
            An Index containing the lengths of each interval.

        See Also
        --------
        Interval.length : Return the length of the Interval.

        Examples
        --------
        >>> intervals = pd.IntervalIndex.from_arrays(
        ...     [1, 2, 3], [4, 5, 6], closed="right"
        ... )
        >>> intervals.length
        Index([3, 3, 3], dtype='int64')

        >>> intervals = pd.IntervalIndex.from_tuples([(1, 5), (6, 10), (11, 15)])
        >>> intervals.length
        Index([4, 4, 4], dtype='int64')
        FrÄ   )r/   rn   ÚlengthrŸ   s    rP   r$  zIntervalIndex.lengtho  s   € õ< �T”ZÔ&¨UÐ3Ñ3Ô3Ð3rR   Úsortc                óh  — | j         j        r"| j        j        r|                      |¦  «        }nm|j         j        rL|j        j        r@|                      ¦   «                              ¦   «         dk    r|                     | ¦  «        }n|                      |¦  «        }|r|                     ¦   «         }|S )zL
        intersection specialized to the case with matching dtypes.
        rB   )r‡   r³   r   Ú_intersection_uniquer±   r²   Ú_intersection_non_uniqueÚsort_values)rŽ   Úotherr%  Útakens       rP   Ú_intersectionzIntervalIndex._intersection’  s²   € ð
 Œ9Ôð 	9 4¤:Ô#7ð 	9Ø×-Ò-¨eÑ4Ô4ˆEˆEØŒZÔ!ð 	9 e¤kÔ&;ð 	9ÀÇ	Â	ÁÄÇÂÑ@QÔ@QÐUVÒ@VÐ@Vð ×.Ò.¨tÑ4Ô4ˆEˆEð ×1Ò1°%Ñ8Ô8ˆEàð 	(Ø×%Ò%Ñ'Ô'ˆEàˆrR   r*  c                ó:  — | j                              |j         ¦  «        }| j                             |j        ¦  «        }||k    |dk    z  }|                     |                     ¦   «         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ð   r   Útakerù   r+   )rŽ   r*  ÚlindexerÚrindexerÚmatchrò   s         rP   r'  z"IntervalIndex._intersection_unique¦  s€   € ð ”9×(Ò(¨¬Ñ4Ô4ˆØ”:×)Ò)¨%¬+Ñ6Ô6ˆà˜XÒ%¨(°bª.Ñ9ˆØ—-’- §¢¡¤°Ô 2Ñ3Ô3ˆÝ˜‘/”/ˆà�yŠy˜Ñ!Ô!Ð!rR   c                óÈ  — t          j        t          | ¦  «        t          ¬¦  «        }| j        rK|j        rDt          j        t          | ¦  «        ¦  «        |                      ¦   «                  d         }d||<   t          t          |j	        |j
        d¬¦  «        ¦  «        }t          t          | j	        | j
        d¬¦  «        ¦  «        D ]\  }}||v rd||<   Œ| |         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)Ústrict)rI   ÚzerosrÞ   rm   r“   r  r±   r´   Úzipr‡   r   r  )rŽ   r*  rà   Úfirst_nan_locÚ
other_tupsr  Útups          rP   r(  z&IntervalIndex._intersection_non_unique¼  sÏ   € õ  Œx�˜D™	œ	­Ð.Ñ.Ô.ˆàŒ<ð 	'˜EœMð 	'ÝœI¥c¨$¡i¤iÑ0Ô0°·²±´Ô=¸aÔ@ˆMØ"&ˆD�Ñå�˜UœZ¨¬¸TÐBÑBÔBÑCÔCˆ
Ý¥ D¤I¨t¬zÀ$Ð GÑ GÔ GÑHÔHð 	ð 	‰FˆAˆsØ�jÐ Ð Ø��Q‘øà�DŒzÐrR   ú
np.ndarrayc                ó    — t          d¦  «        ‚)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects©rÓ   rŸ   s    rP   Ú_get_engine_targetz IntervalIndex._get_engine_targetÛ  s   € õ "ð"ñ
ô 
ð 	
rR   c                ó    — t          d¦  «        ‚)Nz,IntervalIndex does not use libjoin fastpathsr;  )rŽ   Úresults     rP   Ú_from_join_targetzIntervalIndex._from_join_targetä  s   € Ý!Ð"PÑQÔQÐQrR   )NNNNT)rg   rp   r@   rq   rr   rs   rt   ru   rv   rm   rw   r	   )r   NFN)
rg   rp   rt   ru   rr   rm   r@   rq   rw   rk   )
rg   r<   rt   ru   rr   rm   r@   rq   rw   rk   )rw   r   )r�   r   rw   rm   )r—   r˜   rw   rk   )rw   r6   )rw   r£   )F)r§   rm   rw   r¨   ©rw   rm   )r‡   )rÐ   rÑ   )rw   rÖ   )NNN)
rå   r/   ræ   rç   rè   ré   rê   rë   rw   rì   )rå   r/   rw   rô   )rå   rk   rw   rì   )r�   r˜   r  r  )rÐ   r£   )r@   r;   rw   rm   )rw   r/   )r%  rm   )r*  rk   rw   rk   )rw   r9  )2rz   Ú
__module__Ú__qualname__Ú__doc__Ú_typÚ__annotations__Ú_can_hold_stringsr-   Ú	_data_clsr~   Úclassmethodrƒ   rW   r‰   r   r�   r–   rœ   r    r¢   Úpropertyr¦   rª   r®   r³   r½   r¿   r�   rÔ   r”   ró   rú   rî   rï   r  Ú_requires_unique_msgr  r  r  r  r‡   r   r"  r$  r,  r'  r(  r<  r?  Ú__classcell__)r  s   @rP   rk   rk   �   sÑ  ø€ € € € € € ð"Lð Lð\ €Dð ÐÐÑØ&Ð&Ð&Ñ&ØÐÐÑØÐÐÑØ€O€O�OØÐÐÑàÐÐÑØÐÐÑØÐØ€Ið -1Ø"Ø Ø $Ø!%ð,ð ,ð ,ð ,ð ,ð2 ð -4Ø $ØØ"ð-1ð -1ð -1ð -1ñ „[ð-1ð^ ð
 &-Ø $ØØ"ðA1ð A1ð A1ð A1ñ „[ðA1ðF ð &-Ø $ØØ"ð-/ð -/ð -/ð -/ñ „[ð-/ðd ð=ð =ð =ñ „^ð=ðð ð ð ð2<ð <ð <ð <ð ðXð Xð Xñ „^ðXð9ð 9ð 9ð ðð ð ñ „Xðð!Vð !Vð !Vð !Vð !VðJ ð2ð 2ð 2ñ „^ð2ð ðð ð ñ „^ðð. ð/+ð /+ð /+ñ „Xð/+ðb)ð )ð )ð )ð2=ð =ð =ð~<ð <ð <ð <ð <ð:Oð Oð Oð Oðh "Ø Ø $ð,ð ,ð ,ð ,ð ,ð:PJð PJð PJð PJðd
ð 
ð 
ð 
ðWð Wð Wð Wð@ ðFð Fð Fñ „^ðFð 	Vð ð9ð 9ð 9ð 9ð 9ð 9ð ð/ð /ð /ñ „^ð/ðHð Hð Hð Hð3ð 3ð 3ð 3ð ð"2ð "2ð "2ñ „^ð"2ðH ð"3ð "3ð "3ñ „^ð"3ðH ð&1ð &1ð &1ñ „^ð&1ðP ð4ð 4ð 4ñ „Xð4ðDð ð ð ð ð("ð "ð "ð "ð,ð ð ð ð>
ð 
ð 
ð 
ðRð Rð Rð Rð Rð Rð RrR   rk   rw   rm   c                ó’   — 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"   rG   r   r   )Úendpoints    rP   Ú_is_valid_endpointrO  ê  sH   € õ å�hÑÔÝ�x¥Ñ+Ô+Ý�x¥Ñ+Ô+Ø˜Ðð		
ñô ð rR   c                óÌ   — d„ }d„ }t          | ¦  «        rt          |¦  «        p@ || ¦  «        o
 ||¦  «        p* || ¦  «        o
 ||¦  «        pt          j        | |¦  «        S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                ó:   — t          | t          t          f¦  «        S r  )rG   r   r   ©Úxs    rP   ú<lambda>z%_is_type_compatible.<locals>.<lambda>ü  ó   € �Z¨­IµzÐ+BÑCÔC€ rR   c                ó:   — t          | t          t          f¦  «        S r  )rG   r   r   rR  s    rP   rT  z%_is_type_compatible.<locals>.<lambda>ý  rU  rR   )r"   ÚcomÚany_none)ÚaÚbÚis_ts_compatÚis_td_compats       rP   Ú_is_type_compatibler]  ø  s~   € ð DÐC€LØCÐC€Lå	�1‰ŒÐ	&�) A™,œ,ð 	ØˆL˜‰OŒOÐ/  ¨Q¡¤ð	àˆL˜‰OŒOÐ/  ¨Q¡¤ð	õ Œ<˜˜1ÑÔð	rR   r   rt   ru   r<   c           	     ó>  — t          | ¦  «        } t          |¦  «        }| �| n|}|€)t          j        || |¦  «        rt          |¦  «        rdnd}t          j        | |||¦  «        dk    rt          d¦  «        ‚t          | ¦  «        st          d| › �¦  «        ‚t          |¦  «        st          d|› �¦  «        ‚t          |¦  «        }|�Et          |¦  «        s6	 t          |¦  «        }n%# t
          $ r}t          d|› �¦  «        |‚d}~ww xY wt          t          | |¦  «        t          | |¦  «        t          ||¦  «        g¦  «        st          d	¦  «        ‚|�|dz  }t          |¦  «        �r½t          j        d
¦  «        }t          j        | ||¦  «        �rt          | t          j        t          j        f¦  «        r>t          |t          j        t          j        f¦  «        r| j        |j        k    r| j        }nwt          | t$          t          j        f¦  «        sBt          |t$          t          j        f¦  «        s!t          |t$          t          j        f¦  «        rt          j        d¦  «        }t          j        | ||dz  z   |¦  «        }	t)          |	|¦  «        }	nL|€t+          || z
  |z  ¦  «        dz   }n| €||dz
  |z  z
  } n|€| |dz
  |z  z   }t          j        | ||¦  «        }	t          d„ t          j        | ||¦  «        D ¦   «         ¦  «        rt)          |	|¦  «        }	n<t          |t0          ¦  «        rt3          | |||¬¦  «        }	nt5          | |||¬¦  «        }	t6                               |	||t;          |	j        |¬¦  «        ¬¦  «        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
        Object with a fixed frequency.

    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
    :ref:`this link<timeseries.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[us], 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[us], 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]')
    NrB   Ú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 compatibleÚint64Úfloat64gš™™™™™¹?c              3  ó4   K  — | ]}t          |¦  «        V — Œd S r  )r   )Ú.0rS  s     rP   ú	<genexpr>z!interval_range.<locals>.<genexpr>°  s(   è è € ÐEÐE �z˜!‰}Œ}ÐEÐEÐEÐEÐEÐErR   )rÝ   ÚendÚperiodsÚfreq)rË   rg   )rt   rg   r@   )r   rW  rX  r"   Úcount_not_nonerÌ   rO  r,   r   Úallr]  rM   rI   r@   Úall_not_nonerG   ÚintegerÚfloatingÚfloatr  r   r¨   ÚlinspaceÚnot_noner   r3   r8   rk   rƒ   r(   )
rÝ   rf  rg  rh  rt   rg   rN  rã   r@   r„   s
             rP   Úinterval_rangerq    sä  € õD # 5Ñ)Ô)€EÝ
  Ñ
%Ô
%€CØÐ)ˆuˆu¨s€Hà€|�œ W¨e°SÑ9Ô9€|Ý˜hÑ'Ô'Ð0ˆqˆq¨Sˆå
Ô˜%  g¨tÑ4Ô4¸Ò9Ð9Ýð4ñ
ô 
ð 	
õ
 ˜eÑ$Ô$ð QÝÐOÈÐOÐOÑPÔPÐPÝ˜cÑ"Ô"ð MÝÐKÀcÐKÐKÑLÔLÐLå˜wÑ'Ô'€GàÐ¥	¨$¡¤Ðð	Ý˜T‘?”?ˆDˆDøÝð 	ð 	ð 	ÝØPÈ$ÐPÐPñô àðøøøøð	øøøõ å  sÑ+Ô+Ý  tÑ,Ô,Ý  TÑ*Ô*ð	
ñô ð Gõ ÐEÑFÔFÐFð ÐØ�1‰ˆõ �ÑÔñ #SÝœ( 7Ñ+Ô+ˆÝÔ˜E 3¨Ñ-Ô-ñ 	6å˜5¥2¤:­r¬{Ð";Ñ<Ô<ð,å˜s¥R¤Zµ´Ð$=Ñ>Ô>ð,ð ”K 3¤9Ò,Ð,àœ��å˜5¥5­"¬+Ð"6Ñ7Ô7ð,å˜c¥E­2¬;Ð#7Ñ8Ô8ð,õ ˜d¥U­B¬KÐ$8Ñ9Ô9ð,õ
 œ Ñ+Ô+�å”Y˜u c¨T°C©ZÑ&8¸$Ñ?Ô?ˆFÝ+¨F°EÑ:Ô:ˆFˆFð ˆÝ˜s U™{¨tÑ3Ñ4Ô4°qÑ8��Ø�Ø˜w¨™{¨dÑ2Ñ2��Ø�Ø˜w¨™{¨dÑ2Ñ2�å”[ ¨¨WÑ5Ô5ˆFÝÐEÐE¥c¤l°5¸#¸tÑ&DÔ&DÐEÑEÔEÑEÔEð 	;å+¨F°EÑ:Ô:ˆFøå	�H�iÑ	(Ô	(ð SÝ %¨S¸'ÈÐMÑMÔMˆˆå  u°#¸wÈTÐRÑRÔRˆå×$Ò$ØØØÝ F¤L¸Ð@Ñ@Ô@ð	 %ñ ô ð s   ÃC- Ã-
DÃ7D
Ä
Dr@  )NNNNNr   )rt   ru   rg   r<   rw   rk   )`rC  Ú
__future__r   Úoperatorr   r   Útypingr   r   r   r	   ÚnumpyrI   Úpandas._libsr
   Úpandas._libs.intervalr   r   r   Úpandas._libs.tslibsr   r   r   r   r   Úpandas.errorsr   Úpandas.util._decoratorsr   r   Úpandas.util._exceptionsr   Úpandas.core.dtypes.castr   r   r   r   r   r   Úpandas.core.dtypes.commonr   r   r   r    r!   r"   r#   r$   r%   r&   Úpandas.core.dtypes.dtypesr'   r(   Úpandas.core.dtypes.missingr)   Úpandas.core.algorithmsr+   Úpandas.core.arrays.datetimeliker,   Úpandas.core.arrays.intervalr-   Úpandas.core.commonÚcoreÚcommonrW  Úpandas.core.indexersr.   Úpandas.core.indexes.baser/   r0   r1   Úpandas.core.indexes.datetimesr2   r3   Úpandas.core.indexes.extensionr4   r5   Úpandas.core.indexes.multir6   Úpandas.core.indexes.timedeltasr7   r8   Úcollections.abcr9   Úpandas._typingr:   r;   r<   r=   rQ   rT   rZ   rk   rO  r]  rq  rV   rR   rP   ú<module>rŽ     si  ðØ Ð à "Ð "Ð "Ð "Ð "Ð "ðð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð Ð Ð Ð à Ð Ð Ð Ð Ð ðð ð ð ð ð ð ð ð ð ð
ð ð ð ð ð ð ð ð ð ð ð ð ð ð ,Ð +Ð +Ð +Ð +Ð +ðð ð ð ð ð ð ð ð 6Ð 5Ð 5Ð 5Ð 5Ð 5ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð =Ð <Ð <Ð <Ð <Ð <à )Ð )Ð )Ð )Ð )Ð )Ø <Ð <Ð <Ð <Ð <Ð <ðð ð ð ð ð ð !Ð  Ð  Ð  Ð  Ð  Ð  Ð  Ð  Ø :Ð :Ð :Ð :Ð :Ð :ðð ð ð ð ð ð ð ð ð ð
ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð 1Ð 0Ð 0Ð 0Ð 0Ð 0ðð ð ð ð ð ð ð ð
 ð Ø(Ð(Ð(Ð(Ð(Ð(ðð ð ð ð ð ð ð ð ð ð ð ðQð Qð Qð"Qð Qð Qð" ð  ð  ð €�˜kÐ*¨MÀÐEÑEÔEØ€ð	ð 	ð 	ð ñô ð €Ð.°Ð9¸=ÐPTÐUÑUÔUØ€ˆHÑÔðFRð FRð FRð FRð FR�Nñ FRô FRñ Ôñ VÔUñô ñ FÔEð FRðV"ð ð ð ðð ð ð ð €ˆHÑÔà
ØØØ	Ø Ø!(ðwð wð wð wñ Ôðwð wð wrR   