
    Owg.                    h   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/ ddl0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z; ddl<m=c m>Z? ddl@mAZA ddlBm=c mCc mDZE ddlBmFZFmGZGmHZHmIZI ddlJmKZKmLZL ddlMmNZNmOZO ddlPmQZQ ddlRmSZSmTZT erddlUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\  e]eEj                        Z^e^j                  ddd ej                  d      d       d Zad  Zbd! Zc ee;d"   dd#e^d$   d%d& ej                  d'      d(z         eOd)d*ge:d+,       eOg d-e:       eOd.d/ge:d+0       G d1 deN                                  Zdd5d2Zed5d3Zf	 	 	 	 	 	 d6	 	 	 	 	 d7d4Zgy)8z 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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qualnametarget_klassnamec                   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!        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reprlabelrE   s     S/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/indexes/interval.py_get_next_labelrW   u   s    E7DK0E%)Y/0 E
ud#z%'Ir~~a...	%	 qy		||E266**?T%[@Q?RSTT    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!        t        |                    rD   rI   rT   s     rV   _get_prev_labelrZ      s    E7DK0E%)Y/0 E
ud#z%'Ir~~a...	%	 qy		||EBFF7++?T%[@Q?RSTTrX   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     rV   _new_IntervalIndexr`      s    
 3??QrX   classz>Immutable index of intervals that are closed on the same side.rB   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?   summaryrB   extra_attributesextra_methodsexamples
set_closed	to_tuplesT)wrap)	__array__overlapscontainsclosed_leftclosed_right	open_left
open_rightis_emptyis_non_overlapping_monotonicclosed)cachec            	      j    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Ze	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 d>	 	 	 	 	 	 	 	 	 d?d              Ze	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 d>	 	 	 	 	 	 	 	 	 d@d              Ze	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 d>	 	 	 	 	 	 	 	 	 d@d              ZedAd       ZdBdZdCdZedDd       Zd ZedEd       Z e
ej4                  j6                        dFdGd        ZedHd!       ZedHd"       ZedHd#       ZdHd$Zd% Z dIdJd&Z!dKd'Z"	 	 	 dL	 	 	 	 	 	 	 	 	 dMd(Z# e
e$d)   e%z        	 	 	 	 dNd*       Z&dOd+Z'	 	 	 	 dNd,Z(edHd-       Z)d.Z*dP fd/Z+edHd0       Z,dQd1Z-dRd2Z.edSd3       Z/edSd4       Z0edSd5       Z1edSd6       Z2d7 Z3dTd8Z4dTd9Z5dUd:Z6d; Z7 xZ8S )Vr>   intervalindexr;   rs   boolrr   rm   rn   ro   rp   r*   _data_valuesFc                    t        |||       }t        d| j                        5  t        |||||      }d d d        | j	                  |      S # 1 sw Y   xY w)Nr*   )rs   copyrE   verify_integrity)r0   r   __name__r*   _simple_new)r^   datars   rE   r{   rB   r|   arrays           rV   __new__zIntervalIndex.__new__   sa     "$c2= 	!!1E	 ud++	 	s   AA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?   rB   rf   c                    t        d| j                        5  t        j                  ||||      }d d d        | j	                  |      S # 1 sw Y   xY wNr*   )rs   r{   rE   rB   )r   r}   r*   r   r~   )r^   breaksrs   rB   r{   rE   r   s          rV   r   zIntervalIndex.from_breaks   sU    : = 	!--vDE	 u400		 	   AAr]   z        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        c                    t        d| j                        5  t        j                  |||||      }d d d        | j	                  |      S # 1 sw Y   xY w)Nr*   )r{   rE   r   )r   r}   r*   r]   r~   )r^   leftrightrs   rB   r{   rE   r   s           rV   r]   zIntervalIndex.from_arrays  sW    < = 	!--eV$eE	 u400		 	s   AAfrom_tuplesz        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        c                    t        d| j                        5  t        j                  ||||      }d d d        | j	                  |      S # 1 sw Y   xY wr   )r   r}   r*   r   r~   )r^   r   rs   rB   r{   rE   arrs          rV   r   zIntervalIndex.from_tuples;  sU    : = 	Y++DdRWXC	Ys..	Y 	Yr   c                    | j                  | j                        }t        |      }| j                  | j                        }t        |      }t	        ||| j
                        S )Nrs   )_maybe_convert_i8r   r   r   r   rs   )selfr   r   s      rV   _enginezIntervalIndex._engine_  sS     %%dii0,T2&&tzz2-e4D%<<rX   c                    t        |       t        |t              s#t        || j                        r| j
                  S y	 | j                  |       y# t        $ r Y y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)hashrL   r
   r&   rE   hasnansget_locKeyError)r   keys     rV   __contains__zIntervalIndex.__contains__h  sV     	S	#x($S$**5||#	LL 		s    A 	AAc                l    | j                   |   }t        |       j                  || j                        S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r   )rx   rK   r~   _name)r   slobjress      rV   _getitem_slicezIntervalIndex._getitem_slice  s0     jjDz%%c

%;;rX   c                `    t        j                  | j                  | j                  gddg      S )Nr   r   )names)r5   r]   r   r   r   s    rV   _multiindexzIntervalIndex._multiindex  s'    %%tyy$**&=fgEVWWrX   c                    | j                   | j                  | j                  | j                  d}t        t        |       |fd fS )N)r   r   rs   rB   )r   r   rs   rB   r`   rK   )r   r_   s     rV   
__reduce__zIntervalIndex.__reduce__  s<    IIZZkkII	
 "DJ?D88rX   c                     y)z4Return a string of the type inferred from the valuesintervalr\   r   s    rV   inferred_typezIntervalIndex.inferred_type  s     rX   c                t    | j                   j                  |      | j                  j                  |      z   S )N)deep)r   memory_usager   )r   r   s     rV   r   zIntervalIndex.memory_usage  s4     yy%%4%04::3J3JPT3J3UUUrX   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    rV   is_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing  s     DbDz111rX   c                ^   | j                   }| j                  }| j                         j                         dkD  ry|j                  s|j                  ryt               }t        j                  |j                  d            d   }|D ]#  }||   ||   f}||v r y|j                  |       % y)zX
        Return True if the IntervalIndex contains unique elements, else False.
        rG   FT)keepr   )
r   r   isnasum	is_uniquesetrN   where
duplicatedadd)r   r   r   
seen_pairs	check_idxidxpairs          rV   r   zIntervalIndex.is_unique  s    
 yy

99;??q >>U__U
HHT__%_89!<	 	!CIuSz*Dz!NN4 		! rX   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    rV   r   zIntervalIndex.is_overlapping  s    ` ||***rX   c                    t        |dd      }t        |t              st        |t              r| j	                  |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
        rE   N)
rJ   rL   r%   r
   _needs_i8_conversionr   r   r   r1   r6   )r   r   	key_dtypei8_typess       rV   r   z"IntervalIndex._needs_i8_conversion  sU    $ C$/	i/:c83L,,SXX66y-H#x((rX   c                   t        |      rt        |      }t        |      }| j                  |      s|S t	        |      }t        |dd      }t        |t              st        |t              rc| j                  |j                        }| j                  |j                        }|rt        nt        j                  } |||| j                        S |rt        |      \  }}t        |t               r|j"                  }nt        |t$              r|j&                  }nt        |t(        j*                  t(        j,                  f      r[|j/                  d      }nI|j0                  t3        |j4                        }}|j6                  r|j9                  |j:                         }| j0                  j<                  }||k7  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.
        rE   Nr   i8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r   r/   r   r   r"   rJ   rL   r%   r
   r   r   r   r>   r]   rs   r   r   ordinalr   _valuerN   
datetime64rO   viewrE   r-   asi8r   r   _isnansubtype
ValueError)	r   r   scalarr   r   r   constructorkey_i8r   s	            rV   r   zIntervalIndex._maybe_convert_i8  s   " s#C/4C((-J3C$/	i/:c83L))#((3D**3995E&,(-2K2KKeDKK   7 <Iv#v&FI.FR]]BNN$CDT* !$		5?vI{{  szzk2
 **$$i;G9 E##,+/ 
 rX   c                   | 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        |      }|j                  ||      S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr   r   )rr   r   rL   r   r>   NotImplementedErrorr   r   r   rp   rW   ro   rZ   _searchsorted_monotonic)r   rU   sidesub_idxs       rV   r   z%IntervalIndex._searchsorted_monotonicP  s    00M 
 em];<%&TUU
 FNtyy@@GODII$E$EjjG'.iiG~~'...ud;;rX   c                n   | j                  |       t        |t              rX| j                  |j                  k7  rt	        |      | j
                  |j
                  k(  | j                  |j                  k(  z  }nt        || j                        r| j                         }nX| j                  rt        nt        }| j                  rt        nt        }	  || j
                  |       ||| j                        z  }|j                         }|dk(  rt	        |      |dk(  r|j!                         S t#        j$                  |j'                  d            }t        |t(              r6|j*                  *t)        |j,                  t/        |       |j0                        }|S # t        $ r}t	        |      |d}~ww xY w)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   rG   u1)_check_indexing_errorrL   r
   rs   r   r   r   r&   rE   r   rm   r   r   rn   rR   r   argmaxr	   maybe_booleans_to_slicer   slicestopstartlenstep)r   r   maskop_leftop_righterrmatchesr   s           rV   r   zIntervalIndex.get_locm  sR   J 	""3'c8${{cjj(sm#II)djjCII.EFD"3

399;D !,,b"G!..rBH-tyy#.#tzz1JJ
 ((*a<3-a<;;= ))$))D/:c5!chh&6		3t9chh7C
  -sm,-s   'F 	F4#F//F4c                .   t        |t              r| j                  |      }t        |      S t        |j                        sA| j                  |      }| j                  j                  |j                        }t        |      S | j                  |      d   S )Nr   )rL   r>   _get_indexer_unique_sidesr!   rE   r   r   get_indexervalues_get_indexer_pointwiser   )r   targetmethodlimit	toleranceindexers         rV   _get_indexerzIntervalIndex._get_indexer  s     fm,
 44V<G #7++ !. ++F3Fll..v}}=G #7++ ..v6q99rX   get_indexer_non_uniquec                z   t        |      }| j                  |      s%| j                  |      s| j                  |d d      S t	        |t
              re| j                  j                  r>| j                  j                  r(| j                  |      }|dk(  j                         d   }n| j                  |      S t        |j                        s| j                  |      s| j                  |      S | j                  |      }| j                  j!                  |j"                        \  }}t%        |      t%        |      fS )NFr'   r   r   )r/   _should_compare_should_partial_index_get_indexer_non_comparablerL   r>   r   r   r   r   nonzeror   r!   rE   r   r   r   r   r   )r   r   r   missings       rV   r   z$IntervalIndex.get_indexer_non_unique  s    f%##F+D4N4Nv4V 33FD3OO.yy""tzz';';88@"b=113A6226::V\\*$2L2LV2T..v66
 ++F3F#||BB6==QGW"7+-@-IIIrX   c                    | j                   j                  |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   rN   r   )r   r   left_indexerright_indexerr   s        rV   r   z'IntervalIndex._get_indexer_unique_sides  sP     yy,,V[[9

..v||<((<=8,KrX   c                   g g }}t        |      D ]  \  }}	 | j                  |      }t        |t              r8t	        j
                  |j                  |j                  |j                  d      }nEt        j                  |      rt	        j                  |d      }nt	        j                  |      d   }|j                  |        t	        j                   |      }t#        |      t#        |      fS # t        $ r* |j                  |       t	        j                  dg      }Y pt        $ r* |j                  |       t	        j                  dg      }Y w xY w)zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        intprE   rG   )ndminr   r   )	enumerater   rL   r   rN   aranger   r   r   r	   r   r   r   r   appendr   concatenater   )r   r   r   r   ir   locss          rV   r   z$IntervalIndex._get_indexer_pointwise  s    r' 	!FAs&||C(dE*99TZZDIIVTD^^D)88D2D 88D>!,D NN4 )	!, ..)"7+-@-III  &q!xx~$ & q!xx~	&s   BC330E%/EEc                R    | j                    xr | j                  j                  dk  S )N   )r   r   	_na_countr   s    rV   _index_as_uniquezIntervalIndex._index_as_unique  s%    &&&E4<<+A+AA+EErX   zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec                    |j                   <|j                   dk(  s-d}|dk(  rt        |      |dk(  rt        |      st        |      t        |   ||      S )NrG   zClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)r   r   r,   super_convert_slice_indexer)r   r   kindmsg	__class__s       rV   r
  z$IntervalIndex._convert_slice_indexer  s\     CHHM XCu} o%y 05$S/)w-c488rX   c                F    | j                   j                  j                  dv S )NrF   )rE   r   r  r   s    rV   _should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positional+  s     zz!!&&$..rX   c                :    t        | |      j                  ||      S N)rJ   _maybe_cast_slice_bound)r   rU   r   s      rV   r  z%IntervalIndex._maybe_cast_slice_bound3  s    tT"::5$GGrX   c                j    t        |t              syt        | j                  |g      }t	        |       S )NF)rL   r%   r   rE   r!   )r   rE   common_subtypes      rV   _is_comparable_dtypez"IntervalIndex._is_comparable_dtype6  s0    %/)4::u*=>">222rX   c                D    t        | j                  j                  d      S NF)r{   )r-   rx   r   r   s    rV   r   zIntervalIndex.left>  s    TZZ__511rX   c                D    t        | j                  j                  d      S r  )r-   rx   r   r   s    rV   r   zIntervalIndex.rightB  s    TZZ%%E22rX   c                D    t        | j                  j                  d      S r  )r-   rx   midr   s    rV   r  zIntervalIndex.midF  s    TZZ^^%00rX   c                D    t        | j                  j                  d      S r  )r-   rx   lengthr   s    rV   r  zIntervalIndex.lengthJ  s    TZZ&&U33rX   c                   | j                   j                  r(| j                  j                  r| j                  |      }np|j                   j                  rI|j                  j                  r3| j	                         j                         dk  r|j                  |       }n| j                  |      }||j                         }|S )zL
        intersection specialized to the case with matching dtypes.
        rG   )r   r   r   _intersection_uniquer   r   _intersection_non_uniquesort_values)r   othersorttakens       rV   _intersectionzIntervalIndex._intersectionQ  s    
 994::#7#7--e4EZZ!!ekk&;&;		@QUV@V ..t4E 11%8E<%%'ErX   c                (   | j                   j                  |j                         }| j                  j                  |j                        }||k(  |dk7  z  }|j                  |j	                         d         }t        |      }| j                  |      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         rV   r  z"IntervalIndex._intersection_uniquee  sx     99((4::))%++6X%(b.9-- 23/yy!!rX   c                   t        j                  t        |       t              }| j                  rC|j                  r7t        j
                  t        |             | j                            d   }d||<   t        t        |j                  |j                              }t        t        | j                  | j                              D ]  \  }}||v s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)rN   zerosr   rw   r   r   r   r   zipr   r   r   )r   r!  r   first_nan_loc
other_tupsr   tups          rV   r  z&IntervalIndex._intersection_non_unique{  s      xxD	.<<EMMIIc$i0=a@M"&DUZZ56
DIItzz :; 	FAsj Q	 DzrX   c                    t        d      )NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   s    rV   _get_engine_targetz IntervalIndex._get_engine_target  s     ""
 	
rX   c                    t        d      )Nz,IntervalIndex does not use libjoin fastpathsr1  )r   results     rV   _from_join_targetzIntervalIndex._from_join_target  s    !"PQQrX   )NNFNT)rs   IntervalClosedType | NonerE   Dtype | Noner{   rw   rB   Hashable | Noner|   rw   returnr<   )r   NFN)
rs   r6  rB   r8  r{   rw   rE   r7  r9  r>   )
rs   r;   rB   r8  r{   rw   rE   r7  r9  r>   )r9  r   )r   r   r9  rw   )r   r   r9  r>   )r9  r5   )r9  str)F)r   rw   r9  intr9  rw   )r   )r   zLiteral['left', 'right'])r9  zint | slice | np.ndarray)NNN)
r   r-   r   z
str | Noner   z
int | Noner   z
Any | Noner9  npt.NDArray[np.intp])r   r-   r9  z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r   r>   r9  r=  )r   r   r  zLiteral['loc', 'getitem'])r   r:  )rE   r:   r9  rw   )r9  r-   )r!  r>   r9  r>   )r9  z
np.ndarray)9r}   
__module____qualname___typ__annotations___can_hold_stringsr*   	_data_clsr   classmethodr   r+   textwrapdedentr   r]   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  _requires_unique_msgr
  r  r  r  r   r   r  r  r$  r  r  r2  r5  __classcell__)r  s   @rV   r>   r>      s   Z D "&&OI -1" $!%, *, 	,
 , , , 
,, m,$#HOO:
 (
	
. -4 $"1 *1 	1
 1 1 
1) *1 m,$#HOO:
 (
	
0 &- $"1 #	1
 1 1 1 
1) *1 m,$#HOO:
 (
	
. &- $"
/ #
/ 	
/
 
/ 
/ 

/) *
/ = =2< X X9  
 e  (()V *V 2 2  . /+ /+b)2@D<:AL "  $,, , 	,
 , 
,4  !9:=NNOJJ	:J PJ<
JJ	:J@ F F 	V 9 / /H3 2 2 3 3 1 1 4 4(",>
RrX   c                n    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    rL   r   r   )endpoints    rV   _is_valid_endpointrO    s:     hx+x+		
 rX   c                    d }d }t        |       xr t        |      xs>  ||       xr  ||      xs*  ||       xr  ||      xs t        j                  | |      S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                .    t        | t        t        f      S r  )rL   r   r   xs    rV   <lambda>z%_is_type_compatible.<locals>.<lambda>      ZIz+BC rX   c                .    t        | t        t        f      S r  )rL   r   r   rR  s    rV   rT  z%_is_type_compatible.<locals>.<lambda>  rU  rX   )r    comany_none)abis_ts_compatis_td_compats       rV   _is_type_compatibler]    sc     DLCL	1	&)A, 	O/Q	O/Q	 <<1	rX   c                l   t        |       } t        |      }| | n|}|&t        j                  || |      rt        |      rdnd}t        j                  | |||      dk7  rt        d      t        |       st        d|        t        |      st        d|       t        |      }|t        |      s	 t        |      }t        t        | |      t        | |      t        ||      g      st        d	      ||dz  }t        |      rt        j                  | ||      rt        j                  | ||d
z  z   |      }nI|t        || z
  |z        dz   }n| ||dz
  |z  z
  } n|| |dz
  |z  z   }t        j                   | ||      }t        d t        j"                  | ||      D              rOt%        |t        j&                  d            }n/t)        |t*              rt-        | |||      }nt/        | |||      }t0        j3                  |||      S # t
        $ r}t        d|       |d}~ww xY w)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]')
    NrG   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              3  2   K   | ]  }t        |        y wr  )r   ).0rS  s     rV   	<genexpr>z!interval_range.<locals>.<genexpr>_  s     Ez!}Es   int64)r   endperiodsfreq)rB   rs   )r   rW  rX  r    count_not_noner   rO  r)   r   allr]  rR   all_not_nonerN   r   r;  linspacenot_noner   rE   rL   r   r2   r7   r>   r   )	r   re  rf  rg  rB   rs   rN  r   r   s	            rV   interval_rangerm    sZ   @ #5)E
 
%C)usH|WeS9h'qS
%gt494
 	

 e$GwOPPc"EcUKLLw'G	$	T?D s+t,T*	
 EFF 1 E3-YYucTCZ&8$?F sU{t34q8w{d22w{d22[[W5FEcll5#t&DEE ,!F h	*egDQF$5c7QUVF$$V$v$FFi  	I$P	s   6H 	H3H..H3r<  )NNNNNr   )rB   r8  rs   r;   r9  r>   )hrH  
__future__r   operatorr   r   rE  typingr   r   r   numpyrN   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   pandas.core.dtypes.commonr   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*   r+   pandas.core.commoncorecommonrW  pandas.core.indexersr,   pandas.core.indexes.baseindexesbaseibaser-   r.   r/   r0   pandas.core.indexes.datetimesr1   r2   pandas.core.indexes.extensionr3   r4   pandas.core.indexes.multir5   pandas.core.indexes.timedeltasr6   r7   collections.abcr8   pandas._typingr9   r:   r;   r<   r=   dictrI  updaterF  rW   rZ   r`   r>   rO  r]  rm  r\   rX   rV   <module>r     s     "     
  , 6 
 
 
 = ) < !   : ( (  1
 (  001     #<
	
U"U"  
'" S!&)6#HOO
: k*ME	  .9=PTUYRN YR V F;XYR| 	 !(kG
 kG kG kGrX   