
    Mh.                    n   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/  SSK0J1r1J2r2  SSK3J4r4  SSK5J6r6  SSK7J8r8  SSK9J:r:J;r;  SSK<J=s  J>r?  SSK@JArA  SSKBJ=s  JCs  JDrE  SSKBJFrFJGrGJHrHJIrI  SSKJJKrKJLrL  SSKMJNrNJOrO  SSKPJQrQ  SSKRJSrSJTrT  \(       a  SSKUJVrV  SSKWJXrXJYrYJZrZJ[r[J\r\  \]" \ER                  5      r^\^R                  SSS\R                  " S5      S.5        S raS  rbS! rc\" \;S"   SS#\^S$   S%S&\R                  " S'5      S(.-  5      \O" S)S*/\:S+S,9\O" / S-Q\:5      \O" S.S//\:S+S09 " S1 S\N5      5       5       5       5       rdS5S2 jreS5S3 jrf      S6     S7S4 jjrgg)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                   [        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labelrE   s     N/var/www/html/env/lib/python3.13/site-packages/pandas/core/indexes/interval.py_get_next_labelrW   u   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rD   rI   rT   s     rV   _get_prev_labelrZ      s    E7DK0E%)Y/00 E
ud##z%'I'Ir~~a...	%	 	 qy			||EBFF7++?T%[@Q?RSTTrX   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     rV   _new_IntervalIndexr`      s    
 ??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            	        ^  \ 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;   rs   boolrr   rm   rn   ro   rp   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*   )rs   copyrE   verify_integrity)r0   r   __name__r*   _simple_new)r^   datars   rE   r|   rB   r}   arrays           rV   __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?   rB   rf   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*   )rs   r|   rE   rB   )r   r~   r*   r   r   )r^   breaksrs   rB   r|   rE   r   s          rV   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|   rE   r   )r   r~   r*   r]   r   )r^   leftrightrs   rB   r|   rE   r   s           rV   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   rs   rB   r|   rE   arrs          rV   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rs   )_maybe_convert_i8r   r   r   r   rs   )selfr   r   s      rV   _engineIntervalIndex._engine_  sQ     %%dii0,T2&&tzz2-e4D<<rX   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)hashrL   r
   r&   rE   hasnansget_locKeyError)r   keys     rV   __contains__IntervalIndex.__contains__h  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   )ry   rK   r   _name)r   slobjress      rV   _getitem_sliceIntervalIndex._getitem_slice  s.     jjDz%%c

%;;rX   c                \    [         R                  " U R                  U R                  /SS/S9$ )Nr   r   )names)r5   r]   r   r   r   s    rV   _multiindexIntervalIndex._multiindex  s'    %%tyy$**&=fgEVWWrX   c                    U R                   U R                  U R                  U R                  S.n[        [        U 5      U4S 4$ )N)r   r   rs   rB   )r   r   rs   rB   r`   rK   )r   r_   s     rV   
__reduce__IntervalIndex.__reduce__  s<    IIZZkkII	
 "DJ?D88rX   c                    g)z4Return a string of the type inferred from the valuesintervalr\   r   s    rV   inferred_typeIntervalIndex.inferred_type  s     rX   c                h    U R                   R                  US9U R                  R                  US9-   $ )N)deep)r   memory_usager   )r   r   s     rV   r   IntervalIndex.memory_usage  s4     yy%%4%04::3J3JPT3J3UUUrX   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    rV   is_monotonic_decreasing%IntervalIndex.is_monotonic_decreasing  s     DbDz111rX   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.
rG   FT)keepr   )
r   r   isnasum	is_uniquesetrN   where
duplicatedadd)r   r   r   
seen_pairs	check_idxidxpairs          rV   r   IntervalIndex.is_unique  s    
 yy

99;??q >>U__U
HHT__%_89!<	CIuz*D!NN4 	  rX   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    rV   r   IntervalIndex.is_overlapping  s    ` ||***rX   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
rE   N)
rJ   rL   r%   r
   _needs_i8_conversionr   r   r   r1   r6   )r   r   	key_dtypei8_typess       rV   r   "IntervalIndex._needs_i8_conversion  sY    $ C$/	i//:c83L3L,,SXX66y-H#((rX   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.
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   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##,+/ 
 rX   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   )rr   r   rL   r   r>   NotImplementedErrorr   r   r   rp   rW   ro   rZ   _searchsorted_monotonic)r   rU   sidesub_idxs       rV   r   %IntervalIndex._searchsorted_monotonicP  s    00M 
 em];<<%&TUU
 FNtyy@@GODII$E$EjjG'.iiG~~'...u;;rX   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   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   IntervalIndex.get_locm  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                0   [        U[        5      (       a  U R                  U5      nOe[        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   )rL   r>   _get_indexer_unique_sidesr!   rE   r   r   get_indexervalues_get_indexer_pointwiser   )r   targetmethodlimit	toleranceindexers         rV   _get_indexerIntervalIndex._get_indexer  s     fm,,
 44V<G .. ++F3Fll..v}}=G ..v6q99"7++rX   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   )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  $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IrX   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   rN   r   )r   r   left_indexerright_indexerr   s        rV   r   'IntervalIndex._get_indexer_unique_sides  sN     yy,,V[[9

..v||<((<8,KrX   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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   $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    rV   _index_as_uniqueIntervalIndex._index_as_unique  s%    &&&E4<<+A+AA+EErX   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      $ )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"  $IntervalIndex._convert_slice_indexer  s]     CHHM XCu} o%y 055$S/)w-c88rX   c                H    U R                   R                  R                  S;   $ )NrF   )rE   r   r#  r   s    rV   _should_fallback_to_positional,IntervalIndex._should_fallback_to_positional+  s     zz!!&&$..rX   c                6    [        X5      R                  X5      $ N)rJ   _maybe_cast_slice_bound)r   rU   r   s      rV   r,  %IntervalIndex._maybe_cast_slice_bound3  s    t"::5GGrX   c                |    [        U[        5      (       d  g[        U R                  U/5      n[	        U5      (       + $ )NF)rL   r%   r   rE   r!   )r   rE   common_subtypes      rV   _is_comparable_dtype"IntervalIndex._is_comparable_dtype6  s3    %//)4::u*=>">222rX   c                >    [        U R                  R                  SS9$ NF)r|   )r-   ry   r   r   s    rV   r   IntervalIndex.left>  s    TZZ__511rX   c                >    [        U R                  R                  SS9$ r3  )r-   ry   r   r   s    rV   r   IntervalIndex.rightB  s    TZZ%%E22rX   c                >    [        U R                  R                  SS9$ r3  )r-   ry   midr   s    rV   r8  IntervalIndex.midF  s    TZZ^^%00rX   c                >    [        U R                  R                  SS9$ r3  )r-   ry   lengthr   s    rV   r;  IntervalIndex.lengthJ  s    TZZ&&U33rX   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.
rG   )r   r   r   _intersection_uniquer   r   _intersection_non_uniquesort_values)r   othersorttakens       rV   _intersectionIntervalIndex._intersectionQ  s    
 994::#7#7--e4EZZ!!ekk&;&;		@QUV@V ..t4E 11%8E<%%'ErX   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   rA  lindexerrindexermatchr   s         rV   r>  "IntervalIndex._intersection_uniquee  sv     99((4::))%++6%(b.9-- 23/yy!!rX   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)rN   zerosr   rx   r   r  r   r   zipr   r   r  )r   rA  r   first_nan_loc
other_tupsr  tups          rV   r?  &IntervalIndex._intersection_non_unique{  s      xxD	.<<EMMIIc$i0=a@M"&DUZZ56
DIItzz :;FA  < zrX   c                    [        S5      e)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   s    rV   _get_engine_target IntervalIndex._get_engine_target  s     ""
 	
rX   c                    [        S5      e)Nz,IntervalIndex does not use libjoin fastpathsrT  )r   results     rV   _from_join_targetIntervalIndex._from_join_target  s    !"PQQrX   r\   )NNFNT)rs   IntervalClosedType | NonerE   Dtype | Noner|   rx   rB   Hashable | Noner}   rx   returnr<   )r   NFN)
rs   r[  rB   r]  r|   rx   rE   r\  r^  r>   )
rs   r;   rB   r]  r|   rx   rE   r\  r^  r>   )r^  r   )r   r   r^  rx   )r   r   r^  r>   )r^  r5   )r^  str)F)r   rx   r^  intr^  rx   )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^  rb  )r   r   r#  zLiteral['loc', 'getitem'])r   r_  )rE   r:   r^  rx   )r^  r-   )rA  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,  r0  r   r   r8  r;  rD  r>  r?  rU  rY  __static_attributes____classcell__)r%  s   @rV   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rX   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    rL   r   r   )endpoints    rV   _is_valid_endpointrv    s:     hx+x+		
 rX   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+  )rL   r   r   xs    rV   <lambda>%_is_type_compatible.<locals>.<lambda>      ZIz+BCrX   c                .    [        U [        [        45      $ r+  )rL   r   r   ry  s    rV   r{  r|    r}  rX   )r    comany_none)abis_ts_compatis_td_compats       rV   _is_type_compatibler    sa     DLCL	1	&)A, 	O/Q	O/Q	 <<	rX   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]')
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  8   #    U  H  n[        U5      v   M     g 7fr+  )r   ).0rz  s     rV   	<genexpr>!interval_range.<locals>.<genexpr>_  s     E&Dz!}}&Ds   int64)r   endperiodsfreq)rB   rs   )r   r  r  r    count_not_noner   rv  r)   r   allr  rR   all_not_nonerN   r  r`  linspacenot_noner   rE   rL   r   r2   r7   r>   r   )	r   r  r  r  rB   rs   ru  r   r   s	            rV   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ra  )NNNNNr   )rB   r]  rs   r;   r^  r>   )hrn  
__future__r   operatorr   r   rk  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commonr  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=   dictro  updaterl  rW   rZ   r`   r>   rv  r  r  r\   rX   rV   <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rX   