
     -if                    r   S r SSKJr  SSKJrJr  SSKrSSKJrJ	r	J
r
  SSKrSSKJr  SSKJrJrJr  SSKJrJrJrJrJr  SS	KJr  SS
KJrJr  SSKJr  SSK J!r!J"r"J#r#J$r$J%r%  SSK&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0  SSK1J2r2J3r3  SSK4J5r5  SSK6J7r7  SSK8J9r9  SSK:J;r;J<r<  SSK=J>s  J?r@  SSKAJBrB  SSKCJ>s  JDs  JErF  SSKCJGrGJHrHJIrIJJrJ  SSKKJLrLJMrM  SSKNJOrOJPrP  SSKQJRrR  SSKSJTrTJUrU  \(       a  SSKVJWrW  SSKXJYrYJZrZJ[r[J\r\J]r]  \^" \FR                  5      r_\_R                  SSS\R                  " S5      S.5        S rbS  rcS! rd\" \<S"   SS#\_S$   S%S&\R                  " S'5      S(.-  5      \P" S)S*/\;S+S,9\P" / S-Q\;5      \P" S.S//\;S+S09 " S1 S\O5      5       5       5       5       reS5S2 jrfS5S3 jrg      S6     S7S4 jjrhg)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is_string_dtypepandas_dtype)DatetimeTZDtypeIntervalDtype)is_valid_na_for_dtypeunique)validate_periods)IntervalArray_interval_shared_docs)is_valid_positional_slice)Index_index_shared_docsensure_indexmaybe_extract_name)DatetimeIndex
date_range)ExtensionIndexinherit_names)
MultiIndex)TimedeltaIndextimedelta_range)Hashable)DtypeDtypeObjIntervalClosedTypeSelfnptIntervalIndexz"IntervalIndex or list of IntervalszX         name : object, optional
              Name to be stored in the index.
         )klassqualnametarget_klassnamec                   [        U S[        U 5      5      n[        U [        [        45      (       a  Sn[        U5      n[        R                  " US5      (       d  [        U[        5      (       a  U [        R                  " SS5      -   $ [        U5      (       a  U S-   $ [        U5      (       a%  [        R                  " U [        R                  5      $ [        S[!        [        U 5      5       35      e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labelrF   s     O/var/www/html/venv/lib/python3.13/site-packages/pandas/core/indexes/interval.py_get_next_labelrX   v   s    E7DK0E%)Y/00 E
ud##z%'I'Ir~~a...	%	 	 qy			||E266**?T%[@Q?RSTT    c                   [        U S[        U 5      5      n[        U [        [        45      (       a  Sn[        U5      n[        R                  " US5      (       d  [        U[        5      (       a  U [        R                  " SS5      -
  $ [        U5      (       a  U S-
  $ [        U5      (       a&  [        R                  " U [        R                  * 5      $ [        S[!        [        U 5      5       35      erE   rJ   rU   s     rW   _get_prev_labelr[      s    E7DK0E%)Y/00 E
ud##z%'I'Ir~~a...	%	 	 qy			||EBFF7++?T%[@Q?RSTTrY   c                &    U R                   " S0 UD6$ )zj
This is called upon unpickling, rather than the default which doesn't have
arguments and breaks __new__.
 )from_arrays)clsds     rW   _new_IntervalIndexra      s    
 ??QrY   classz>Immutable index of intervals that are closed on the same side.rC   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@   summaryrC   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            	        ^  \ rS rSr% SrS\S'   S\S'   S\S'   S\S'   S\S	'   S\S
'   S\S'   S\S'   Sr\r     S>           S?S jjr	\
\" \S   S \R                  " S5      \R                  " S5      S.-  5          S@         SAS jj5       5       r\
\" \S   S \R                  " S5      \R                  " S5      S.-  5          S@         SBS jj5       5       r\
\" \S   S \R                  " S5      \R                  " S5      S.-  5          S@         SBS jj5       5       r\SCS j5       rSDS jrSES jr\SFS j5       rS r\SGS  j5       r\" \R6                  R8                  5      SHSIS! jj5       r\SJS" j5       r\SJS# j5       r\SJS$ j5       rSJS% jr S& r!SKSLS' jjr"SMS( jr#   SN         SOS) jjr$\" \%S*   \&-  5          SPS+ j5       r'SQS, jr(    SPS- jr)\SJS. j5       r*S/r+SRU 4S0 jjr,\SJS1 j5       r-SSS2 jr.STS3 jr/\SUS4 j5       r0\SUS5 j5       r1\SUS6 j5       r2\SUS7 j5       r3S8 r4SVS9 jr5SVS: jr6SWS; jr7S< r8S=r9U =r:$ )Xr?      intervalindexr<   rt   boolrs   rn   ro   rp   rq   r+   _data_valuesFc           	         [        XQU 5      n[        SU R                  5         [        UUUUUS9nS S S 5        U R	                  WU5      $ ! , (       d  f       N = f)Nr+   )rt   copyrF   verify_integrity)r1   r   __name__r+   _simple_new)r_   datart   rF   r}   rC   r~   arrays           rW   __new__IntervalIndex.__new__   sX     "$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@   rC   rg   c                    [        SU R                  5         [        R                  " XXES9nS S S 5        U R	                  WUS9$ ! , (       d  f       N= fNr+   )rt   r}   rF   rC   )r   r   r+   r   r   )r_   breaksrt   rC   r}   rF   r   s          rW   r   IntervalIndex.from_breaks   sJ    : =!--D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           	         [        SU R                  5         [        R                  " XX5US9nS S S 5        U R	                  WUS9$ ! , (       d  f       N= f)Nr+   )r}   rF   r   )r   r   r+   r^   r   )r_   leftrightrt   rC   r}   rF   r   s           rW   r^   IntervalIndex.from_arrays  sL    < =!--Ve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                    [        SU R                  5         [        R                  " XXES9nS S S 5        U R	                  WUS9$ ! , (       d  f       N= fr   )r   r   r+   r   r   )r_   r   rt   rC   r}   rF   arrs          rW   r   IntervalIndex.from_tuples<  sE    : =++DdXC >s.. >=r   c                    U R                  U R                  5      n[        U5      nU R                  U R                  5      n[        U5      n[	        XU R
                  S9$ )Nrt   )_maybe_convert_i8r   r   r   r   rt   )selfr   r   s      rW   _engineIntervalIndex._engine`  sQ     %%dii0,T2&&tzz2-e4D<<rY   c                    [        U5        [        U[        5      (       d'  [        XR                  5      (       a  U R
                  $ g U R                  U5        g! [         a     gf = f)z
return a boolean if this key is IN the index
We *only* accept an Interval

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

Returns
-------
bool
FT)hashrM   r
   r'   rF   hasnansget_locKeyError)r   keys     rW   __contains__IntervalIndex.__contains__i  sZ     	S	#x(($S**55||#	LL 		s   	A 
A('A(c                d    U R                   U   n[        U 5      R                  X R                  S9$ )z8
Fastpath for __getitem__ when we know we have a slice.
r   )rz   rL   r   _name)r   slobjress      rW   _getitem_sliceIntervalIndex._getitem_slice  s.     jjDz%%c

%;;rY   c                \    [         R                  " U R                  U R                  /SS/S9$ )Nr   r   )names)r6   r^   r   r   r   s    rW   _multiindexIntervalIndex._multiindex  s'    %%tyy$**&=fgEVWWrY   c                    U R                   U R                  U R                  U R                  S.n[        [        U 5      U4S 4$ )N)r   r   rt   rC   )r   r   rt   rC   ra   rL   )r   r`   s     rW   
__reduce__IntervalIndex.__reduce__  s<    IIZZkkII	
 "DJ?D88rY   c                    g)z4Return a string of the type inferred from the valuesintervalr]   r   s    rW   inferred_typeIntervalIndex.inferred_type  s     rY   c                h    U R                   R                  US9U R                  R                  US9-   $ )N)deep)r   memory_usager   )r   r   s     rW   r   IntervalIndex.memory_usage  s4     yy%%4%04::3J3JPT3J3UUUrY   c                &    U SSS2   R                   $ )zh
Return True if the IntervalIndex is monotonic decreasing (only equal or
decreasing values), else False
N)is_monotonic_increasingr   s    rW   is_monotonic_decreasing%IntervalIndex.is_monotonic_decreasing  s     DbDz111rY   c                r   U R                   nU R                  nU R                  5       R                  5       S:  a  gUR                  (       d  UR                  (       a  g[        5       n[        R                  " UR                  SS95      S   nU H#  nX   X%   4nXc;   a    gUR                  U5        M%     g)zH
Return True if the IntervalIndex contains unique elements, else False.
rH   FT)keepr   )
r   r   isnasum	is_uniquesetrO   where
duplicatedadd)r   r   r   
seen_pairs	check_idxidxpairs          rW   r   IntervalIndex.is_unique  s    
 yy

99;??q >>U__U
HHT__%_89!<	CIuz*D!NN4 	  rY   c                .    U R                   R                  $ )ap  
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    rW   r   IntervalIndex.is_overlapping  s    ` ||***rY   c                    [        USS5      n[        U[        5      (       d  [        U[        5      (       a  U R	                  UR
                  5      $ [        [        [        [        4n[        X5      $ )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
rF   N)
rK   rM   r&   r
   _needs_i8_conversionr   r   r   r2   r7   )r   r   	key_dtypei8_typess       rW   r   "IntervalIndex._needs_i8_conversion  sY    $ C$/	i//:c83L3L,,SXX66y-H#((rY   c                   [        U5      (       a  [        U5      n[        U5      nU R                  U5      (       d  U$ [	        U5      n[        USS5      n[        U[        5      (       d  [        U[        5      (       ad  U R                  UR                  5      nU R                  UR                  5      nU(       a  [        O[        R                  nU" XEU R                  S9$ U(       a  [        U5      u  p7[        U[         5      (       a  UR"                  nO[        U[$        5      (       a  UR&                  nO[        U[(        R*                  [(        R,                  45      (       a  UR/                  S5      nOMUR0                  [3        UR4                  5      psUR6                  (       a  UR9                  UR:                  ) 5      nU R0                  R<                  nX:w  a  [?        SU SU 35      eU$ )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.
rF   Nr   i8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r   r0   r   r   r"   rK   rM   r&   r
   r   r   r   r?   r^   rt   r   r   ordinalr   _valuerO   
datetime64rP   viewrF   r.   asi8r   r   _isnansubtype
ValueError)	r   r   scalarr   r   r   constructorkey_i8r   s	            rW   r   IntervalIndex._maybe_convert_i8  s   " s#C/4C((--J3C$/	i//:c83L3L))#((3D**3995E&,(-2K2KKDKK   7 <I#v&&FI..FR]]BNN$CDDT* !$		5?v{{  szzk2
 **$$;G9 E##,+/ 
 rY   c                   U R                   (       d  [        S5      e[        U[        [        45      (       a  [        S5      eUS:X  a  U R                  R                  (       d!  US:X  aD  U R                  R                  (       d)  U R                  nU R                  (       a  [        U5      nO(U R                  nU R                  (       a  [        U5      nUR                  X5      $ )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   )rs   r   rM   r   r?   NotImplementedErrorr   r   r   rq   rX   rp   r[   _searchsorted_monotonic)r   rV   sidesub_idxs       rW   r   %IntervalIndex._searchsorted_monotonicQ  s    00M 
 em];<<%&TUU
 FNtyy@@GODII$E$EjjG'.iiG~~'...u;;rY   c                   U R                  U5        [        U[        5      (       aY  U R                  UR                  :w  a  [	        U5      eU R
                  UR
                  :H  U R                  UR                  :H  -  nO[        XR                  5      (       a  U R                  5       nOaU R                  (       a  [        O[        nU R                  (       a  [        O[        n U" U R
                  U5      U" XR                  5      -  nUR                  5       nUS:X  a  [	        U5      eUS:X  a  UR!                  5       $ ["        R$                  " UR'                  S5      5      n[        U[(        5      (       a7  UR*                  c*  [)        UR,                  [/        U 5      UR0                  5      nU$ ! [         a  n[	        U5      UeSnAff = f)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   rH   u1)_check_indexing_errorrM   r
   rt   r   r   r   r'   rF   r   rn   r   r   ro   rS   r   argmaxr	   maybe_booleans_to_slicer   slicestopstartlenstep)r   r   maskop_leftop_righterrmatchesr   s           rW   r   IntervalIndex.get_locn  sW   J 	""3'c8$${{cjj(sm#II)djjCII.EFD"3

3399;D !,,b"G!..rBH-tyy#.#zz1JJ
 ((*a<3-a<;;= ))$))D/:c5!!chh&6		3t9chh7C
  -sm,-s   &&F6 6
G GGc                d   [        U[        5      (       a  U R                  U5      nO[        UR                  5      (       dQ  [        UR                  5      (       d7  U R                  U5      nU R                  R                  UR                  5      nOU R                  U5      S   $ [        U5      $ )Nr   )rM   r?   _get_indexer_unique_sidesr!   rF   r#   r   r   get_indexervalues_get_indexer_pointwiser   )r   targetmethodlimit	toleranceindexers         rW   _get_indexerIntervalIndex._get_indexer  s     fm,,
 44V<G!&,,//?6<<3P3P ++F3Fll..v}}=G ..v6q99"7++rY   get_indexer_non_uniquec                   [        U5      nU R                  U5      (       d'  U R                  U5      (       d  U R                  US SS9$ [	        U[
        5      (       ao  U R                  R                  (       aC  U R                  R                  (       a(  U R                  U5      nUS:H  R                  5       S   nOU R                  U5      $ [        UR                  5      (       d  U R                  U5      (       d  U R                  U5      $ U R                  U5      nU R                  R!                  UR"                  5      u  p#[%        U5      [%        U5      4$ )NFr(   r   r   )r0   _should_compare_should_partial_index_get_indexer_non_comparablerM   r?   r   r   r   r   nonzeror   r!   rF   r   r   r  r   r   )r   r   r   missings       rW   r  $IntervalIndex.get_indexer_non_unique  s    f%##F++D4N4Nv4V4V 33FD3OO..yy""tzz';';88@"b=113A6226::V\\**$2L2LV2T2T..v66
 ++F3F#||BB6==QG"7+-@-IIIrY   c                    U R                   R                  UR                   5      nU R                  R                  UR                  5      n[        R                  " X#:H  US5      nU$ )zJ
_get_indexer specialized to the case where both of our sides are unique.
r   )r   r   r   rO   r   )r   r   left_indexerright_indexerr   s        rW   r   'IntervalIndex._get_indexer_unique_sides  sN     yy,,V[[9

..v||<((<8,KrY   c                   / / p2[        U5       H  u  pE U R                  U5      n[        U[        5      (       a6  [        R
                  " UR                  UR                  UR                  SS9nOK[        R                  " U5      (       a  [        R                  " USS9nO[        R                  " U5      S   n UR                  U5        M     [        R                   " U5      n[#        U5      [#        U5      4$ ! [         a+    UR                  U5        [        R                  " S/5      n Nu[         a+    UR                  U5        [        R                  " S/5      n Nf = f)zF
pointwise implementation for get_indexer and get_indexer_non_unique.
intprF   rH   )ndminr   r   )	enumerater   rM   r   rO   aranger   r   r   r	   r   r   r   r   appendr   concatenater   )r   r   r   r	  ir   locss          rW   r   $IntervalIndex._get_indexer_pointwise  s    r'FA&||C(dE**99TZZDIIVTD^^D))88D2D 88D>!,D NN4 ) (, ..)"7+-@-III  &q!xx~$ & q!xx~	&s$   AC=10C="C==2E%11E%$E%c                d    U R                   (       + =(       a    U R                  R                  S:  $ )N   )r   r   	_na_countr   s    rW   _index_as_uniqueIntervalIndex._index_as_unique  s%    &&&E4<<+A+AA+EErY   zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec                   > UR                   bD  UR                   S:X  d4  SnUS:X  a  [        U5      eUS:X  a  [        U5      (       d  [        U5      e[        TU ]  X5      $ )NrH   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       rW   r#  $IntervalIndex._convert_slice_indexer  s]     CHHM XCu} o%y 055$S/)w-c88rY   c                H    U R                   R                  R                  S;   $ )NrG   )rF   r   r$  r   s    rW   _should_fallback_to_positional,IntervalIndex._should_fallback_to_positional,  s     zz!!&&$..rY   c                6    [        X5      R                  X5      $ N)rK   _maybe_cast_slice_bound)r   rV   r   s      rW   r-  %IntervalIndex._maybe_cast_slice_bound4  s    t"::5GGrY   c                |    [        U[        5      (       d  g[        U R                  U/5      n[	        U5      (       + $ )NF)rM   r&   r   rF   r!   )r   rF   common_subtypes      rW   _is_comparable_dtype"IntervalIndex._is_comparable_dtype7  s3    %//)4::u*=>">222rY   c                >    [        U R                  R                  SS9$ NF)r}   )r.   rz   r   r   s    rW   r   IntervalIndex.left?  s    TZZ__511rY   c                >    [        U R                  R                  SS9$ r4  )r.   rz   r   r   s    rW   r   IntervalIndex.rightC  s    TZZ%%E22rY   c                >    [        U R                  R                  SS9$ r4  )r.   rz   midr   s    rW   r9  IntervalIndex.midG  s    TZZ^^%00rY   c                >    [        U R                  R                  SS9$ r4  )r.   rz   lengthr   s    rW   r<  IntervalIndex.lengthK  s    TZZ&&U33rY   c                   U R                   R                  (       a-  U R                  R                  (       a  U R                  U5      nO{UR                   R                  (       aO  UR                  R                  (       a4  U R	                  5       R                  5       S::  a  UR                  U 5      nOU R                  U5      nUc  UR                  5       nU$ )z<
intersection specialized to the case with matching dtypes.
rH   )r   r   r   _intersection_uniquer   r   _intersection_non_uniquesort_values)r   othersorttakens       rW   _intersectionIntervalIndex._intersectionR  s    
 994::#7#7--e4EZZ!!ekk&;&;		@QUV@V ..t4E 11%8E<%%'ErY   c                &   U R                   R                  UR                   5      nU R                  R                  UR                  5      nX#:H  US:g  -  nUR                  UR	                  5       S   5      n[        U5      nU R                  U5      $ )z
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   rB  lindexerrindexermatchr   s         rW   r?  "IntervalIndex._intersection_uniquef  sv     99((4::))%++6%(b.9-- 23/yy!!rY   c                   [         R                  " [        U 5      [        S9nU R                  (       aH  UR                  (       a7  [         R
                  " [        U 5      5      U R                  5          S   nSX#'   [        [        UR                  UR                  5      5      n[        [        U R                  U R                  5      5       H  u  pVXd;   d  M  SX%'   M     X   $ )z
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)rO   zerosr   ry   r   r  r   r   zipr   r   r  )r   rB  r   first_nan_loc
other_tupsr  tups          rW   r@  &IntervalIndex._intersection_non_unique|  s      xxD	.<<EMMIIc$i0=a@M"&DUZZ56
DIItzz :;FA  < zrY   c                    [        S5      e)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   s    rW   _get_engine_target IntervalIndex._get_engine_target  s     ""
 	
rY   c                    [        S5      e)Nz,IntervalIndex does not use libjoin fastpathsrU  )r   results     rW   _from_join_targetIntervalIndex._from_join_target  s    !"PQQrY   r]   )NNFNT)rt   IntervalClosedType | NonerF   Dtype | Noner}   ry   rC   Hashable | Noner~   ry   returnr=   )r   NFN)
rt   r\  rC   r^  r}   ry   rF   r]  r_  r?   )
rt   r<   rC   r^  r}   ry   rF   r]  r_  r?   )r_  r   )r   r   r_  ry   )r   r   r_  r?   )r_  r6   )r_  str)F)r   ry   r_  intr_  ry   )r   )r   zLiteral['left', 'right'])r_  zint | slice | np.ndarray)NNN)
r   r.   r   z
str | Noner   z
int | Noner   z
Any | Noner_  npt.NDArray[np.intp])r   r.   r_  z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r   r?   r_  rc  )r   r   r$  zLiteral['loc', 'getitem'])r   r`  )rF   r;   r_  ry   )r_  r.   )rB  r?   r_  r?   )r_  z
np.ndarray);r   
__module____qualname____firstlineno___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-  r1  r   r   r9  r<  rE  r?  r@  rV  rZ  __static_attributes____classcell__)r&  s   @rW   r?   r?      s~   Z D "&&OI -1" $!%, *, 	,
 , , , 
,, m,$OO:
 !
	
. -4 $"1 *1 	1
 1 1 
1) *1 m,$OO:
 !
	
0 &- $"1 #	1
 1 1 1 
1) *1 m,$OO:
 !
	
. &- $"
/ #
/ 	
/
 
/ 
/ 

/) *
/ = =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 RrY   c                n    [        [        U 5      [        U [        5      [        U [        5      U SL /5      $ )zB
Helper for interval_range to check if start/end are valid types.
N)anyr    rM   r   r   )endpoints    rW   _is_valid_endpointrw    s:     hx+x+		
 rY   c                    S nS n[        U 5      =(       a    [        U5      =(       dR    U" U 5      =(       a    U" U5      =(       d4    U" U 5      =(       a    U" U5      =(       d    [        R                  " X5      $ )zC
Helper for interval_range to check type compat of start/end/freq.
c                .    [        U [        [        45      $ r,  )rM   r   r   xs    rW   <lambda>%_is_type_compatible.<locals>.<lambda>      ZIz+BCrY   c                .    [        U [        [        45      $ r,  )rM   r   r   rz  s    rW   r|  r}    r~  rY   )r    comany_none)abis_ts_compatis_td_compats       rW   _is_type_compatibler    sa     DLCL	1	&)A, 	O/Q	O/Q	 <<	rY   c                   [        U 5      n [        U5      nU b  U OUnUc0  [        R                  " X U5      (       a  [        U5      (       a  SOSn[        R                  " XX#5      S:w  a  [        S5      e[        U 5      (       d  [        SU  35      e[        U5      (       d  [        SU 35      e[        U5      nUb  [        U5      (       d   [        U5      n[        [        X5      [        X5      [        X5      /5      (       d  [        S	5      eUb  US-  n[        U5      (       a  [        R                  " XU5      (       a  [        R                  " XUS
-  -   U5      nOIUc  [        X-
  U-  5      S-   nOU c  XS-
  U-  -
  n OUc
  XS-
  U-  -   n[        R                   " XU5      n[        S [        R"                  " XU5       5       5      (       a   [%        U[        R&                  " S5      5      nO*[)        U[*        5      (       a  [-        XX#S9nO
[/        XX#S9n[0        R3                  XUS9$ ! [
         a  n[        SU 35      UeSnAff = f)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]')
NrH   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  8   #    U  H  n[        U5      v   M     g 7fr,  )r   ).0r{  s     rW   	<genexpr>!interval_range.<locals>.<genexpr>`  s     E&Dz!}}&Ds   int64)r   endperiodsfreq)rC   rt   )r   r  r  r    count_not_noner   rw  r*   r   allr  rS   all_not_nonerO   r  ra  linspacenot_noner   rF   rM   r   r3   r8   r?   r   )	r   r  r  r  rC   rt   rv  r   r   s	            rW   interval_ranger    sU   @ #5)E
 
%C)usH|WS99h''qS
%g494
 	

 e$$GwOPPc""EcUKLLw'G	$	T?D +,*	
  EFF 1 E--YYuTCZ&8$?F s{t34q8{d22{d22[[W5FEcll5t&DEEE ,!F h	**egQF$57VF$$Vv$FFi  	I$P	s   H< <
IIIrb  )NNNNNr   )rC   r^  rt   r<   r_  r?   )iro  
__future__r   operatorr   r   rl  typingr   r   r   numpyrO   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#   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commonr  pandas.core.indexersr-   pandas.core.indexes.baseindexesbaseibaser.   r/   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=   r>   dictrp  updaterm  rX   r[   ra   r?   rw  r  r  r]   rY   rW   <module>r     s     "     
  , 6    = ) < !   : ( (  1
 (  001     #<
	
U"U"  
'" S!&)6OO
: k*ME	  .9=PTUYRN YR V F;XYR| 	 !(kG
 kG kG kGrY   