
    Eg.                       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^_                    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                                                          Zdd:d4Zed:d5Zf	 	 	 	 	 	 d;d<d9ZgdS )=z 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     Q/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/indexes/interval.py_get_next_labelrW   u   s    E7DKK00E%)Y/00 ! E
ud## Uz%'I'I Ur~a....	%	 	  Uqy			 U|E26***ST%[[@Q@QSST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KK00E%)Y/00 ! E
ud## Uz%'I'I Ur~a....	%	 	  Uqy			 U|EBF7+++ST%[[@Q@QSST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            	      ~    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	 	 	 	 	 dddedZe	 e
ed         d  ej        d           ej        d          dz            	 	 	 	 dfdgd                        Ze	 e
ed          d  ej        d           ej        d!          dz            	 	 	 	 dfdhd"                        Ze	 e
ed#         d  ej        d           ej        d$          dz            	 	 	 	 dfdhd%                        Zedid'            Zdjd*Zdkd-Zedld/            Zd0 Zedmd2            Z e
ej        j                  dndod5            Zedpd6            Zedpd7            Zedpd8            Zdpd9Zd: Z dqdrd>Z!dsd@Z"	 	 	 dtdudJZ# e
e$dK         e%z            dvdM            Z&dwdNZ'dvdOZ(edpdP            Z)dQZ*dx fdTZ+edpdU            Z,dydVZ-dzdXZ.ed{dY            Z/ed{dZ            Z0ed{d[            Z1ed{d\            Z2d] Z3d|d_Z4d|d`Z5d}dbZ6dc Z7 xZ8S )~r>   intervalindexr;   rs   boolrr   rm   rn   ro   rp   r*   _data_valuesFNTIntervalClosedType | NonerE   Dtype | NonecopyrB   Hashable | Noneverify_integrityreturnr<   c                    t          |||           }t          d| j                  5  t          |||||          }d d d            n# 1 swxY w Y   |                     ||          S )Nr*   )rs   r|   rE   r~   )r0   r   __name__r*   _simple_new)r^   datars   rE   r|   rB   r~   arrays           rV   __new__zIntervalIndex.__new__   s     "$c22== 	 	!!1  E	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ud+++s   A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   rightc                    t          d| j                  5  t          j        ||||          }d d d            n# 1 swxY w Y   |                     ||          S Nr*   )rs   r|   rE   rB   )r   r   r*   r   r   )r^   breaksrs   rB   r|   rE   r   s          rV   r   zIntervalIndex.from_breaks   s    : == 	 	!-vD  E	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 u4000   ;??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            n# 1 swxY w Y   |                     ||          S )Nr*   )r|   rE   r   )r   r   r*   r]   r   )r^   leftr   rs   rB   r|   rE   r   s           rV   r]   zIntervalIndex.from_arrays  s    < == 	 	!-eV$e  E	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 u4000s   <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            n# 1 swxY w Y   |                     ||          S r   )r   r   r*   r   r   )r^   r   rs   rB   r|   rE   arrs          rV   r   zIntervalIndex.from_tuples;  s    : == 	Y 	Y+DdRWXXXC	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Y 	Ys...r   r   c                    |                      | j                  }t          |          }|                      | j                  }t          |          }t	          ||| j                  S )Nrs   )_maybe_convert_i8r   r   r   r   rs   )selfr   r   s      rV   _enginezIntervalIndex._engine_  s_     %%di00,T22&&tz22-e44D%<<<<rX   keyr   c                    t          |           t          |t                    st          || j                  r| j        S dS 	 |                     |           dS # t          $ r Y dS w xY w)z
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FT)hashrL   r
   r&   rE   hasnansget_locKeyError)r   r   s     rV   __contains__zIntervalIndex.__contains__h  s     	S			#x(( 	$S$*55 $|#5	LL4 	 	 	55	s   A 
A)(A)slobjslicec                n    | j         |         }t          |                               || j                  S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r   )rx   rK   r   _name)r   r   ress      rV   _getitem_slicezIntervalIndex._getitem_slice  s1     jDzz%%c
%;;;rX   r5   c                J    t          j        | j        | j        gddg          S )Nr   r   )names)r5   r]   r   r   r   s    rV   _multiindexzIntervalIndex._multiindex  s&    %ty$*&=fgEVWWWWrX   c                j    | 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;    IZkI	
 
 "DJJ?D88rX   strc                    dS )z4Return a string of the type inferred from the valuesintervalr\   r   s    rV   inferred_typezIntervalIndex.inferred_type  s	     zrX   deepintc                p    | j                             |          | j                            |          z   S )N)r   )r   memory_usager   )r   r   s     rV   r   zIntervalIndex.memory_usage  s6     y%%4%004:3J3JPT3J3U3U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     DDbDz11rX   c                t   | j         }| j        }|                                                                 dk    rdS |j        s|j        rdS t                      }t          j        |                    d                    d         }|D ].}||         ||         f}||v r dS |	                    |           /dS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        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    
 y
99;;??q  5> 	U_ 	4UU
HT__%_8899!<	 	! 	!CIuSz*Dz!!uuNN4    trX   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                  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  sl    $ C$//	i// 	7:c83L3L 	7,,SX666y-H#x(((rX   c                   t          |          rt          |          }t          |          }|                     |          s|S t	          |          }t          |dd          }t          |t                    st          |t                    r\| 	                    |j
                  }| 	                    |j                  }|rt          nt          j        } |||| j                  S |rt          |          \  }}t          |t                     r|j        }nt          |t$                    r|j        }nyt          |t(          j        t(          j        f          r|                    d          }n=|j        t3          |j                  }}|j        r|                    |j                   }| j        j        }||k    rt?          d| d|           |S )a  
        Maybe convert a given key to its equivalent i8 value(s). Used as a
        preprocessing step prior to IntervalTree queries (self._engine), which
        expects numeric data.

        Parameters
        ----------
        key : scalar or list-like
            The key that should maybe be converted to i8.

        Returns
        -------
        scalar or list-like
            The original key if no conversion occurred, int if converted scalar,
            Index with an int64 dtype if converted list-like.
        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   "  	5s##C/44C((-- 	J3C$//	i// 	:c83L3L 	))#(33D**3955E&,K((-2KK;eDK     	3 7 < <Iv#v&& +FI.. +FR]BN$CDD +T** !$	5??vI{ 3  szk22
 *$i/G / /#,/ /  
 rX   r   sideLiteral['left', 'right']c                n   | j         st          d          t          |t          t          f          rt          d          |dk    r| j        j        s|dk    r*| j        j        s| j        }| j	        rt          |          }n| j        }| j        rt          |          }|                    ||          S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr   r   )rr   r   rL   r   r>   NotImplementedErrorr   r   r   rp   rW   ro   rZ   _searchsorted_monotonic)r   rU   r   sub_idxs       rV   r   z%IntervalIndex._searchsorted_monotonicP  s    0 	M  
 em];<< 	V%&TUUU
 FNNty@NGOODI$EOjG /'..iG~ /'....ud;;;rX   int | slice | np.ndarrayc                n   |                      |           t          |t                    rA| j        |j        k    rt	          |          | j        |j        k    | j        |j        k    z  }nt          || j                  r| 	                                }nq| j
        rt          nt          }| j        rt          nt          }	  || j        |           ||| j                  z  }n"# t          $ r}t	          |          |d}~ww xY w|                                }|dk    rt	          |          |dk    r|                                S t#          j        |                    d                    }t          |t(                    r/|j        (t)          |j        t/          |           |j                  }|S )a  
        Get integer location, slice or boolean mask for requested label.

        Parameters
        ----------
        key : label

        Returns
        -------
        int if unique index, slice if monotonic index, else mask

        Examples
        --------
        >>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
        >>> index = pd.IntervalIndex([i1, i2])
        >>> index.get_loc(1)
        0

        You can also supply a point inside an interval.

        >>> index.get_loc(1.5)
        1

        If a label is in several intervals, you get the locations of all the
        relevant intervals.

        >>> i3 = pd.Interval(0, 2)
        >>> overlapping_index = pd.IntervalIndex([i1, i2, i3])
        >>> overlapping_index.get_loc(0.5)
        array([ True, False,  True])

        Only exact matches will be returned if an interval is provided.

        >>> index.get_loc(pd.Interval(0, 1))
        0
        Nr   rG   u1)_check_indexing_errorrL   r
   rs   r   r   r   r&   rE   r   rm   r   r   rn   rR   r   argmaxr	   maybe_booleans_to_slicer   r   stopstartlenstep)r   r   maskop_leftop_righterrmatchesr   s           rV   r   zIntervalIndex.get_locm  s   J 	""3'''c8$$ 	-{cj((smm#I)djCI.EFDD"3
33 
	-99;;DD !,4bb"G!.6rrBH-wty#..#tz1J1JJ - - -smm,- ((**a<<3--a<<;;== )$))D//::c5!! 	8ch&6	3t99ch77C
s   #C% %
D/C??Dtargetr-   method
str | Nonelimit
int | None	tolerance
Any | Nonenpt.NDArray[np.intp]c                >   t          |t                    r|                     |          }ndt          |j                  s5|                     |          }| j                            |j                  }n| 	                    |          d         S t          |          S )Nr   )rL   r>   _get_indexer_unique_sidesr!   rE   r   r   get_indexervalues_get_indexer_pointwiser   )r   r   r   r   r   indexers         rV   _get_indexerzIntervalIndex._get_indexer  s     fm,, 	:
 44V<<GG .. 	: ++F33Fl..v}==GG ..v66q99"7+++rX   get_indexer_non_unique1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c                   t          |          }|                     |          s-|                     |          s|                     |d d          S t	          |t
                    ra| j        j        r@| j        j        r4| 	                    |          }|dk    
                                d         }n|                     |          S t          |j                  s|                     |          s|                     |          S |                     |          }| j                            |j                  \  }}t%          |          t%          |          fS )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  sT    f%%##F++ 	RD4N4Nv4V4V 	R 33FD3OOO.. 	Ry" ;tz'; ;88@@"b=1133A6226:::V\** 	R$2L2LV2T2T 	R..v666
 ++F33F#|BB6=QQGW"7++-@-I-IIIrX   c                    | j                             |j                   }| j                            |j                  }t          j        ||k    |d          }|S )zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r   )r   r   r   rN   r   )r   r   left_indexerright_indexerr   s        rV   r   z'IntervalIndex._get_indexer_unique_sides  sO     y,,V[99
..v|<<(<=8,KKrX   c                   g g }}t          |          D ]#\  }}	 |                     |          }t          |t                    r(t	          j        |j        |j        |j        d          }nEt          j
        |          rt	          j        |d          }nt	          j        |          d         }no# t          $ r- |                    |           t	          j        dg          }Y n9t          $ r- |                    |           t	          j        dg          }Y nw xY w|                    |           %t	          j        |          }t#          |          t#          |          fS )zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        intp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  sh    r'' 	! 	!FAs&||C((dE** -9TZDIVTTTDD^D)) -8D222DD 8D>>!,D & & &q!!!x~~$ & & & q!!!x~~	& NN4    .))"7++-@-I-IIIs   BB334D)3DDc                2    | j          o| j        j        dk     S )N   )r   r   	_na_countr   s    rV   _index_as_uniquezIntervalIndex._index_as_unique  s    &&E4<+AA+EErX   zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquekindLiteral['loc', 'getitem']c                    |j         F|j         dk    s;d}|dk    rt          |          |dk    rt          |          st          |          t                                          ||          S )NrG   zClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)r   r   r,   super_convert_slice_indexer)r   r   r  msg	__class__s       rV   r  z$IntervalIndex._convert_slice_indexer  ss     CHMM XCu}} oo%y  055 *$S//)ww--c4888rX   c                (    | j         j        j        dv S )NrF   )rE   r   r  r   s    rV   _should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positional+  s     z!&$..rX   c                J    t          | |                              ||          S N)rJ   _maybe_cast_slice_bound)r   rU   r   s      rV   r   z%IntervalIndex._maybe_cast_slice_bound3  s"    tT""::5$GGGrX   r:   c                |    t          |t                    sdS t          | j        |g          }t	          |           S )NF)rL   r%   r   rE   r!   )r   rE   common_subtypes      rV   _is_comparable_dtypez"IntervalIndex._is_comparable_dtype6  s>    %// 	5)4:u*=>>">2222rX   c                8    t          | j        j        d          S NF)r|   )r-   rx   r   r   s    rV   r   zIntervalIndex.left>  s    TZ_51111rX   c                8    t          | j        j        d          S r%  )r-   rx   r   r   s    rV   r   zIntervalIndex.rightB  s    TZ%E2222rX   c                8    t          | j        j        d          S r%  )r-   rx   midr   s    rV   r(  zIntervalIndex.midF  s    TZ^%0000rX   c                8    t          | j        j        d          S r%  )r-   rx   lengthr   s    rV   r*  zIntervalIndex.lengthJ  s    TZ&U3333rX   c                h   | j         j        r"| j        j        r|                     |          }nm|j         j        rL|j        j        r@|                                                                 dk    r|                    |           }n|                     |          }||                                }|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    
 9 	94:#7 	9--e44EEZ! 	9ek&; 	9		@Q@QUV@V@V ..t44EE 11%88E<%%''ErX   r/  c                :   | j                             |j                   }| j                            |j                  }||k    |dk    z  }|                    |                                d                   }t          |          }|                     |          S )a'  
        Used when the IntervalIndex does not have any common endpoint,
        no matter left or right.
        Return the intersection with another IntervalIndex.
        Parameters
        ----------
        other : IntervalIndex
        Returns
        -------
        IntervalIndex
        r   r   )r   r   r   taker   r(   )r   r/  lindexerrindexermatchr   s         rV   r,  z"IntervalIndex._intersection_uniquee  s     9((44:))%+66X%(b.9-- 233//yy!!!rX   c                   t          j        t          |           t                    }| j        rK|j        rDt          j        t          |                     |                                          d         }d||<   t          t          |j	        |j
                            }t          t          | j	        | j
                            D ]\  }}||v rd||<   | |         S )a  
        Used when the IntervalIndex does have some common endpoints,
        on either sides.
        Return the intersection with another IntervalIndex.

        Parameters
        ----------
        other : IntervalIndex

        Returns
        -------
        IntervalIndex
        r  r   T)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      xD		...< 	'EM 	'Ic$ii00=a@M"&DUZ5566
DItz : :;; 	 	FAsj  QDzrX   
np.ndarrayc                     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 fastpathsr@  )r   results     rV   _from_join_targetzIntervalIndex._from_join_target  s    !"PQQQrX   )NNFNT)rs   rz   rE   r{   r|   rw   rB   r}   r~   rw   r   r<   )r   NFN)
rs   rz   rB   r}   r|   rw   rE   r{   r   r>   )
rs   r;   rB   r}   r|   rw   rE   r{   r   r>   )r   r   )r   r   r   rw   )r   r   r   r>   )r   r5   )r   r   )F)r   rw   r   r   r   rw   )r   )r   r   )r   r   )NNN)
r   r-   r   r   r   r   r   r   r   r   )r   r-   r   r   )r   r>   r   r   )r   r   r  r  )r   r   )rE   r:   r   rw   )r   r-   )r/  r>   r   r>   )r   r>  )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*  r2  r,  r-  rA  rD  __classcell__)r  s   @rV   r>   r>      s        Z D &&&&OOOI -1" $!%, , , , ,, Xm,$#HO: 
 ( 
 
	
 . -4 $"1 1 1 1)  [*1 Xm,$#HO: 
 ( 
 
	
 0 &- $"1 1 1 1)  [*1 Xm,$#HO: 
 ( 
 
	
 . &- $"
/ 
/ 
/ 
/)  [*
/ = = = ^=   2< < < < X X X ^X9 9 9    X
 Xe ())V V V V *)V 2 2 2 ^2    ^. /+ /+ /+ X/+b) ) ) )2@ @ @D< < < < <:A A A AL "  $, , , , ,4 X !9:=NNOOJ J J POJ<
 
 
 
J J J J@ F F F ^F 	V 9 9 9 9 9 9 / / / ^/H H H H3 3 3 3 2 2 2 ^2 3 3 3 ^3 1 1 1 ^1 4 4 4 X4  (" " " ",   >
 
 
 
R R R R R R RrX   r   rw   c                    t          t          |           t          | t                    t          | t                    | du g          S )zJ
    Helper for interval_range to check if start/end are valid types.
    N)anyr    rL   r   r   )endpoints    rV   _is_valid_endpointrW    sH     hx++x++		
  rX   c                    d }d }t          |           rt          |          p@ ||           o
 ||          p* ||           o
 ||          pt          j        | |          S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                :    t          | t          t          f          S r  )rL   r   r   xs    rV   <lambda>z%_is_type_compatible.<locals>.<lambda>      ZIz+BCC rX   c                :    t          | t          t          f          S r  )rL   r   r   rZ  s    rV   r\  z%_is_type_compatible.<locals>.<lambda>  r]  rX   )r    comany_none)abis_ts_compatis_td_compats       rV   _is_type_compatiblere    s~     DCLCCL	1	&)A,, 	LOO/Q	LOO/Q	 <1	rX   r   r}   r;   c                6   t          |           } t          |          }| | n|}|)t          j        || |          rt          |          rdnd}t          j        | |||          dk    rt          d          t          |           st          d|            t          |          st          d|           t          |          }|Et          |          s6	 t          |          }n%# t
          $ r}t          d|           |d}~ww xY wt          t          | |          t          | |          t          ||          g          st          d	          ||dz  }t          |          rt          j        | ||          rt          j        | ||d
z  z   |          }nL|t          || z
  |z            dz   }n| ||dz
  |z  z
  } n|| |dz
  |z  z   }t          j        | ||          }t          d t          j        | ||          D                       r"t%          |t          j        d                    }n<t)          |t*                    rt-          | |||          }nt/          | |||          }t0                              |||          S )a  
    Return a fixed frequency IntervalIndex.

    Parameters
    ----------
    start : numeric or datetime-like, default None
        Left bound for generating intervals.
    end : numeric or datetime-like, default None
        Right bound for generating intervals.
    periods : int, default None
        Number of periods to generate.
    freq : numeric, str, Timedelta, datetime.timedelta, or DateOffset, default None
        The length of each interval. Must be consistent with the type of start
        and end, e.g. 2 for numeric, or '5H' for datetime-like.  Default is 1
        for numeric and 'D' for datetime-like.
    name : str, default None
        Name of the resulting IntervalIndex.
    closed : {'left', 'right', 'both', 'neither'}, default 'right'
        Whether the intervals are closed on the left-side, right-side, both
        or neither.

    Returns
    -------
    IntervalIndex

    See Also
    --------
    IntervalIndex : An Index of intervals that are all closed on the same side.

    Notes
    -----
    Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
    exactly three must be specified. If ``freq`` is omitted, the resulting
    ``IntervalIndex`` will have ``periods`` linearly spaced elements between
    ``start`` and ``end``, inclusively.

    To learn more about datetime-like frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.

    Examples
    --------
    Numeric ``start`` and  ``end`` is supported.

    >>> pd.interval_range(start=0, end=5)
    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
                  dtype='interval[int64, right]')

    Additionally, datetime-like input is also supported.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   end=pd.Timestamp('2017-01-04'))
    IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00],
                   (2017-01-02 00:00:00, 2017-01-03 00:00:00],
                   (2017-01-03 00:00:00, 2017-01-04 00:00:00]],
                  dtype='interval[datetime64[ns], right]')

    The ``freq`` parameter specifies the frequency between the left and right.
    endpoints of the individual intervals within the ``IntervalIndex``.  For
    numeric ``start`` and ``end``, the frequency must also be numeric.

    >>> pd.interval_range(start=0, periods=4, freq=1.5)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
                  dtype='interval[float64, right]')

    Similarly, for datetime-like ``start`` and ``end``, the frequency must be
    convertible to a DateOffset.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   periods=3, freq='MS')
    IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00],
                   (2017-02-01 00:00:00, 2017-03-01 00:00:00],
                   (2017-03-01 00:00:00, 2017-04-01 00:00:00]],
                  dtype='interval[datetime64[ns], right]')

    Specify ``start``, ``end``, and ``periods``; the frequency is generated
    automatically (linearly spaced).

    >>> pd.interval_range(start=0, end=6, periods=4)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
              dtype='interval[float64, right]')

    The ``closed`` parameter specifies which endpoints of the individual
    intervals within the ``IntervalIndex`` are closed.

    >>> pd.interval_range(end=5, periods=4, closed='both')
    IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
                  dtype='interval[int64, both]')
    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  4   K   | ]}t          |          V  d S r  )r   ).0r[  s     rV   	<genexpr>z!interval_range.<locals>.<genexpr>_  s(      EEz!}}EEEEEErX   int64)r   endperiodsfreq)rB   rs   )r   r_  r`  r    count_not_noner   rW  r)   r   allre  rR   all_not_nonerN   r
  r   linspacenot_noner   rE   rL   r   r2   r7   r>   r   )	r   rm  rn  ro  rB   rs   rV  r   r   s	            rV   interval_rangeru    s   @ #5))E
 
%
%C)uusH|WeS99|h''0qqS
%gt44994
 
 	

 e$$ QOOOPPPc"" MKcKKLLLw''G	$	T??DD 	 	 	P$PP 	 s++t,,T**	
  G EFFF 1  WE3-- 	6YucTCZ&8$??FF sU{t344q8w{d22w{d22[W55FEEcl5#t&D&DEEEEE 		 ,!! F h	** 	WegDQQQFF$5c7QUVVVF$$V$v$FFFs   C- -
D7D

DrE  )NNNNNr   )rB   r}   rs   r;   r   r>   )hrP  
__future__r   operatorr   r   rM  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=   dictrQ  updaterN  rW   rZ   r`   r>   rW  re  ru  r\   rX   rV   <module>r     s(       " " " " " "                                    
              , + + + + +        6 5 5 5 5 5             
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        = < < < < < ) ) ) ) ) ) < < < < < <        !                 : : : : : : ( ( ( ( ( ( ( ( ( ( ( (                          1 0 0 0 0 0       
  	((((((              D011     #<
 
	
 
  U U U"U U U"      
'" S!&)6#HO
 
  : k*MEEE	 	 	   .9=PTUUUYR YR YR YR YRN YR YR VU  FE; XYR|       	 !(kG kG kG kG kG kG kGrX   