
    `Vg                    N   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 dd	l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( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z>m?Z? ddl@mAc mBZC ddlDmEZE ddlFmAc mGc mHZI ddlFmJZJmKZKmLZLmMZM ddlNmOZOmPZP ddlQmRZRmSZS ddlTmUZU ddlVmWZWmXZX  eYeIj                        ZZeZj                  ddd ej                  d      d       d Z]d Z^d Z_ e e?d    dd!eZd"   d#d$d% ej                  d&      d'z         eSd(d)ge>d*+       eSg d,e>       eSd-d.ge>d*/       G d0 deR                                  Z`d4d1Zad4d2Zb	 	 	 	 	 	 d5	 	 	 	 	 d6d3Zcy)7z define the IntervalIndex     )annotations)leltN)AnyHashableLiteral)lib)IntervalIntervalMixinIntervalTree)
BaseOffset	Timedelta	Timestamp	to_offset)DtypeDtypeObjIntervalClosedTypenpt)InvalidIndexError)Appendercache_readonly)rewrite_exception)find_common_typeinfer_dtype_from_scalarmaybe_box_datetimelikemaybe_downcast_numeric)ensure_platform_intis_datetime64tz_dtypeis_datetime_or_timedelta_dtypeis_dtype_equalis_floatis_float_dtype
is_integeris_integer_dtypeis_interval_dtypeis_list_like	is_numberis_object_dtype	is_scalar)IntervalDtype)is_valid_na_for_dtypeunique)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IntervalIndexz"IntervalIndex or list of IntervalszX         name : object, optional
              Name to be stored in the index.
         )klassqualnametarget_klassnamec                z   t        | dt        |             }t        | t        t        f      rd}t        |      s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dtype
datetime64   nsz%cannot determine next label for type getattrtype
isinstancer   r   r   r   nptimedelta64r$   r"   	nextafterinfty	TypeErrorreprlabelrC   s     ]/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/indexes/interval.py_get_next_labelrT   o   s    E7DK0E%)Y/0%e,0Ee0Lr~~a...	%	 qy		||E288,,?T%[@Q?RSTT    c                |   t        | dt        |             }t        | t        t        f      rd}t        |      st        |      r| t        j                  dd      z
  S t        |      r| dz
  S t        |      r%t        j                  | t        j                         S t        dt        t        |                    rB   rG   rQ   s     rS   _get_prev_labelrW   }   s    E7DK0E%)Y/0%e,0Ee0Lr~~a...	%	 qy		||EBHH9--?T%[@Q?RSTTrU   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     rS   _new_IntervalIndexr]      s    
 3??QrU   classz>Immutable index of intervals that are closed on the same side.r@   z0.20.0z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=   summaryr@   versionadded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	 	 	 	 	 dA	 	 	 	 	 	 	 	 	 dBdZe	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 dC	 	 	 	 	 	 	 	 	 dDd              Ze	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 dC	 	 	 	 	 	 	 	 	 dEd              Ze	 e
ed   d  ej                  d       ej                  d      dz        	 	 	 	 dC	 	 	 	 	 	 	 	 	 dFd              ZedGd       ZdHdZedId       Zd ZedJd       Z e
ej2                  j4                        dKdLd        ZedMd!       ZedMd"       ZedMd#       ZdMd$Zd% ZdNdOd&Z 	 dP	 	 	 dQd'Z!	 	 	 dR	 	 	 	 	 	 	 	 	 dSd(Z" e
e#d)   e$z        	 	 	 	 dTd*       Z%dUd+Z&	 	 	 	 dTd,Z'edMd-       Z(d.Z)dV fd/Z*edMd0       Z+e,jZ                  fdWd1Z.dXd2Z/edYd3       Z0edYd4       Z1edYd5       Z2edYd6       Z3dZd7Z4d8dd9	 d[ fd:Z5d\dJd;Z6d< Z7d]d=Z8d]d>Z9d^d?Z:d@ Z; xZ<S )_r<   intervalindexr   rq   boolrp   rk   rl   rm   rn   r.   _data_valuesFNc                    t        |||       }t        d| j                        5  t        |||||      }d d d        | j	                  |      S # 1 sw Y   xY w)Nr.   )rq   copyrC   verify_integrity)r4   r   __name__r.   _simple_new)r[   datarq   rC   ry   r@   rz   arrays           rS   __new__zIntervalIndex.__new__   sa     "$c2= 	!!1E	 ud++	 	s   AAfrom_breakszY
             name : str, optional
                  Name of the resulting IntervalIndex.z        Examples
        --------
        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        )r=   r@   rd   c                    t        d| j                        5  t        j                  ||||      }d d d        | j	                  |      S # 1 sw Y   xY wNr.   )rq   ry   rC   r@   )r   r{   r.   r   r|   )r[   breaksrq   r@   ry   rC   r~   s          rS   r   zIntervalIndex.from_breaks   sU    : = 	!--vDE	 u400		 	   AArZ   z        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        c                    t        d| j                        5  t        j                  |||||      }d d d        | j	                  |      S # 1 sw Y   xY w)Nr.   )ry   rC   r   )r   r{   r.   rZ   r|   )r[   leftrightrq   r@   ry   rC   r~   s           rS   rZ   zIntervalIndex.from_arrays  sW    < = 	!--eV$eE	 u400		 	s   AAfrom_tuplesz        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        c                    t        d| j                        5  t        j                  ||||      }d d d        | j	                  |      S # 1 sw Y   xY wr   )r   r{   r.   r   r|   )r[   r}   rq   r@   ry   rC   arrs          rS   r   zIntervalIndex.from_tuples1  sU    : = 	Y++DdRWXC	Ys..	Y 	Yr   c                    | j                  | j                        }| j                  | j                        }t        ||| j                        S )Nrq   )_maybe_convert_i8r   r   r   rq   )selfr   r   s      rS   _enginezIntervalIndex._engineU  s=    %%dii0&&tzz2D%<<rU   c                    t        |       t        |t              s#t        || j                        r| j
                  S y	 | j                  |       y# t        $ r Y yw xY w)z
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FT)hashrJ   r
   r+   rC   hasnansget_locKeyError)r   keys     rS   __contains__zIntervalIndex.__contains__[  sV     	S	#x($S$**5||#	LL 		s    A 	AAc                `    t        j                  | j                  | j                  gddg      S )Nr   r   )names)r9   rZ   r   r   r   s    rS   _multiindexzIntervalIndex._multiindext  s'    %%tyy$**&=fgEVWWrU   c                    | j                   | j                  | j                  | j                  d}t        t        |       |fd fS )N)r   r   rq   r@   )r   r   rq   r@   r]   rI   )r   r\   s     rS   
__reduce__zIntervalIndex.__reduce__x  s<    IIZZkkII	
 "DJ?D88rU   c                     y)z4Return a string of the type inferred from the valuesintervalrY   r   s    rS   inferred_typezIntervalIndex.inferred_type  s     rU   c                t    | j                   j                  |      | j                  j                  |      z   S )N)deep)r   memory_usager   )r   r   s     rS   r   zIntervalIndex.memory_usage  s4     yy%%4%04::3J3JPT3J3UUUrU   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    rS   is_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing  s     DbDz111rU   c                ^   | j                   }| j                  }| j                         j                         dkD  ry|j                  s|j                  ryt               }t        j                  |j                  d            d   }|D ]#  }||   ||   f}||v r y|j                  |       % y)zX
        Return True if the IntervalIndex contains unique elements, else False.
        rE   FT)keepr   )
r   r   isnasum	is_uniquesetrK   where
duplicatedadd)r   r   r   
seen_pairs	check_idxidxpairs          rS   r   zIntervalIndex.is_unique  s    
 yy

99;??q >>U__U
HHT__%_89!<	 	!CIuSz*Dz!NN4 		! rU   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    rS   r   zIntervalIndex.is_overlapping  s    ` ||***rU   c                    t        |      st        |t              r| j                  |j                        S t
        t        t        t        f}t        ||      S )a	  
        Check if a given key needs i8 conversion. Conversion is necessary for
        Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An
        Interval-like requires conversion if its endpoints are one of the
        aforementioned types.

        Assumes that any list-like data has already been cast to an Index.

        Parameters
        ----------
        key : scalar or Index-like
            The key that should be checked for i8 conversion

        Returns
        -------
        bool
        )	r%   rJ   r
   _needs_i8_conversionr   r   r   r5   r:   )r   r   i8_typess      rS   r   z"IntervalIndex._needs_i8_conversion  sE    $ S!ZX%>,,SXX66y-H#x((rU   c                   |}t        |      rt        |      }| j                  |      s|S t        |      }t	        |      st        |t              rc| j                  |j                        }| j                  |j                        }|rt        nt        j                  } |||| j                        S |rt        |d      \  }}t        j                  |      r|j                   }nt        |t"              r|j$                  }nt        |t&        j(                  t&        j*                  f      r[|j-                  d      }nI|j.                  t1        |j2                        }}|j4                  r|j7                  |j8                         }| j.                  j:                  }	t=        |	|      s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,
            Int64Index if converted list-like.
        r   T)pandas_dtypei8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r&   r3   r   r)   r%   rJ   r
   r   r   r   r<   rZ   rq   r   r	   	is_periodordinalr   valuerK   rD   rL   viewrC   r1   asi8r   r   _isnansubtyper    
ValueError)
r   r   originalscalarr   r   constructor	key_dtypekey_i8r   s
             rS   r   zIntervalIndex._maybe_convert_i8  st   " s#C((-O3S!ZX%>))#((3D**3995E&,(-2K2KKeDKK   7$ OIv}}S!FI.FR]]BNN$CDT* !$		5?vI{{  szzk2
 **$$gy1;G9 E##,+/ 
 rU   c                   | j                   st        d      t        |t        t        f      rt        d      |dk(  r| j                  j                  s|dk(  r:| j                  j                  s$| j                  }| j                  r/t        |      }n#| j                  }| j                  rt        |      }|j                  ||      S )Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr   r   )rp   r   rJ   r   r<   NotImplementedErrorr   r   r   rn   rT   rm   rW   _searchsorted_monotonic)r   rR   sidesub_idxs       rS   r   z%IntervalIndex._searchsorted_monotonic9  s    00M 
 em];<%&TUU
 FNtyy@@GODII$E$EjjG'.iiG~~'...ud;;rU   c                   | j                  |       | j                  |       t        |t              rX| j                  |j                  k7  rt        |      | j                  |j                  k(  | j                  |j                  k(  z  }nt        || j                        r| j                         }nX| j                  rt        nt        }| j                  rt        nt        }	  || j                  |       ||| j                        z  }|j!                         }|dk(  rt        |      |dk(  r|j#                         S t%        j&                  |j)                  d            }	t        |	t*              r6|	j,                  *t+        |	j.                  t1        |       |	j2                        }	|	S # t        $ r}t        |      |d}~ww xY w)a1  
        Get integer location, slice or boolean mask for requested label.

        Parameters
        ----------
        key : label
        method : {None}, optional
            * default: matches where the label is within an interval only.

            .. deprecated:: 1.4

        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   rE   u1)_check_indexing_method_check_indexing_errorrJ   r
   rq   r   r   r   r+   rC   r   rk   r   r   rl   rO   r   argmaxr	   maybe_booleans_to_slicer   slicestopstartlenstep)
r   r   method	tolerancemaskop_leftop_righterrmatchesress
             rS   r   zIntervalIndex.get_locV  s`   V 	##F+""3'c8${{cjj(sm#II)djjCII.EFD"3

399;D !,,b"G!..rBH-tyy#.#tzz1JJ
 ((*a<3-\;;= ))$))D/:c5!chh&6		3t9chh7C
  -sm,-s   #'F+ +	G4G  Gc                .   t        |t              r| j                  |      }t        |      S t        |j                        sA| j                  |      }| j                  j                  |j                        }t        |      S | j                  |      d   S )Nr   )rJ   r<   _get_indexer_unique_sidesr(   rC   r   r   get_indexervalues_get_indexer_pointwiser   )r   targetr   limitr   indexers         rS   _get_indexerzIntervalIndex._get_indexer  s     fm,
 44V<G #7++ !. ++F3Fll..v}}=G #7++ ..v6q99rU   get_indexer_non_uniquec                z   t        |      }| j                  |      s%| j                  |      s| j                  |d d      S t	        |t
              re| j                  j                  r>| j                  j                  r(| j                  |      }|dk(  j                         d   }n| j                  |      S t        |j                        s| j                  |      s| j                  |      S | j                  |      }| j                  j!                  |j"                        \  }}t%        |      t%        |      fS )NFr,   r   r   )r3   _should_compare_should_partial_index_get_indexer_non_comparablerJ   r<   r   r   r   r   nonzeror   r(   rC   r   r   r   r   r   )r   r   r   missings       rS   r   z$IntervalIndex.get_indexer_non_unique  s    f%##F+D4N4Nv4V 33FD3OO.yy""tzz';';88@"b=113A6226::V\\*$2L2LV2T..v66
 ++F3F#||BB6==QGW"7+-@-IIIrU   c                    | j                   j                  |j                         }| j                  j                  |j                        }t        j                  ||k(  |d      }|S )zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r   )r   r   r   rK   r   )r   r   left_indexerright_indexerr   s        rS   r   z'IntervalIndex._get_indexer_unique_sides  sP     yy,,V[[9

..v||<((<=8,KrU   c                   g g }}t        |      D ]  \  }}	 | j                  |      }t        |t              r8t	        j
                  |j                  |j                  |j                  d      }nEt        j                  |      rt	        j                  |d      }nt	        j                  |      d   }|j                  |        t	        j                   |      }t#        |      t#        |      fS # t        $ r* |j                  |       t	        j                  dg      }Y pt        $ r* |j                  |       t	        j                  dg      }Y w xY w)zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        intprC   rE   )ndminr   r   )	enumerater   rJ   r   rK   aranger   r   r   r	   r#   r~   r   r   appendr   concatenater   )r   r   r   r   ir   locss          rS   r   z$IntervalIndex._get_indexer_pointwise  s    r' 	!FAs&||C(dE*99TZZDIIVTD^^D)88D2D 88D>!,D NN4 )	!, ..)"7+-@-III  &q!xx~$ & q!xx~	&s   BC330E%/EEc                R    | j                    xr | j                  j                  dk  S )N   )r   r   	_na_countr   s    rS   _index_as_uniquezIntervalIndex._index_as_unique  s%    &&&E4<<+A+AA+EErU   zKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec                    |j                   <|j                   dk(  s-d}|dk(  rt        |      |dk(  rt        |      st        |      t        |   ||      S )NrE   zClabel-based slicing with step!=1 is not supported for IntervalIndexlocgetitem)r   r   r0   super_convert_slice_indexer)r   r   kindmsg	__class__s       rS   r  z$IntervalIndex._convert_slice_indexer  s\     CHHM XCu} o%"05$S/)w-c488rU   c                F    | j                   j                  j                  dv S )N)mM)rC   r   r  r   s    rS   _should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positional  s     zz!!&&*44rU   c                `    | j                  |dd       t        | |      j                  ||      S )Nr  _maybe_cast_slice_bound)_deprecated_argrH   r  )r   rR   r   r  s       rS   r  z%IntervalIndex._maybe_cast_slice_bound$  s/    T6+DEtT"::5$GGrU   c                j    t        |t              syt        | j                  |g      }t	        |       S )NF)rJ   r*   r   rC   r(   )r   rC   common_subtypes      rS   _is_comparable_dtypez"IntervalIndex._is_comparable_dtype(  s0    %/)4::u*=>">222rU   c                D    t        | j                  j                  d      S NF)ry   )r1   rv   r   r   s    rS   r   zIntervalIndex.left0  s    TZZ__511rU   c                D    t        | j                  j                  d      S r  )r1   rv   r   r   s    rS   r   zIntervalIndex.right4  s    TZZ%%E22rU   c                D    t        | j                  j                  d      S r  )r1   rv   midr   s    rS   r  zIntervalIndex.mid8  s    TZZ^^%00rU   c                D    t        | j                  j                  d      S r  )r1   rv   lengthr   s    rS   r  zIntervalIndex.length<  s    TZZ&&U33rU   c                >    |t        | j                  |            z   S )N)na_rep)list_format_native_types)r   headerr  s      rS   _format_with_headerz!IntervalIndex._format_with_headerD  s     T66f6EFFFrU   NaNr  quotingc               (    t        |   d||d|S )Nr#  rY   )r  r  )r   r  r$  kwargsr
  s       rS   r  z"IntervalIndex._format_native_typesH  s     w+U67UfUUrU   c                ^    | j                   j                         dz   | j                         z   S )N,)rv   _format_data_format_space)r   r@   s     rS   r)  zIntervalIndex._format_dataN  s*     zz&&(3.1C1C1EEErU   c                   | j                   j                  r(| j                  j                  r| j                  |      }np|j                   j                  rI|j                  j                  r3| j	                         j                         dk  r|j                  |       }n| j                  |      }||j                         }|S )zL
        intersection specialized to the case with matching dtypes.
        rE   )r   r   r   _intersection_uniquer   r   _intersection_non_uniquesort_values)r   othersorttakens       rS   _intersectionzIntervalIndex._intersectionV  s    
 994::#7#7--e4EZZ!!ekk&;&;		@QUV@V ..t4E 11%8E<%%'ErU   c                (   | j                   j                  |j                         }| j                  j                  |j                        }||k(  |dk7  z  }|j                  |j	                         d         }t        |      }| j                  |      S )a'  
        Used when the IntervalIndex does not have any common endpoint,
        no matter left or right.
        Return the intersection with another IntervalIndex.
        Parameters
        ----------
        other : IntervalIndex
        Returns
        -------
        IntervalIndex
        r   r   )r   r   r   taker   r-   )r   r/  lindexerrindexermatchr   s         rS   r,  z"IntervalIndex._intersection_uniquej  sx     99((4::))%++6X%(b.9-- 23/yy!!rU   c                   t        j                  t        |       t              }| j                  rC|j                  r7t        j
                  t        |             | j                            d   }d||<   t        t        |j                  |j                              }t        t        | j                  | j                              D ]  \  }}||v sd||<    | |   S )a  
        Used when the IntervalIndex does have some common endpoints,
        on either sides.
        Return the intersection with another IntervalIndex.

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

        Returns
        -------
        IntervalIndex
        r   r   T)rK   zerosr   ru   r   r   r   r   zipr   r   r   )r   r/  r   first_nan_loc
other_tupsr   tups          rS   r-  z&IntervalIndex._intersection_non_unique  s      xxD	.<<EMMIIc$i0=a@M"&DUZZ56
DIItzz :; 	FAsj Q	 DzrU   c                    t        d      )NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objectsr   r   s    rS   _get_engine_targetz IntervalIndex._get_engine_target  s     ""
 	
rU   c                    t        d      )Nz,IntervalIndex does not use libjoin fastpathsr?  )r   results     rS   _from_join_targetzIntervalIndex._from_join_target  s    !"PQQrU   )NNFNT)
rC   Dtype | Nonery   ru   r@   r   rz   ru   returnr<   )r   NFN)
rq   zIntervalClosedType | Noner@   r   ry   ru   rC   rD  rE  r<   )
rq   r   r@   r   ry   ru   rC   rD  rE  r<   )
rq   strr@   r   ry   ru   rC   rD  rE  r<   )rE  r   )r   r   rE  ru   )rE  r9   )rE  rF  )F)r   ru   rE  intrE  ru   )r   )r   zLiteral['left', 'right'])NN)r   
str | NonerE  zint | slice | np.ndarray)NNN)
r   r1   r   rI  r   z
int | Noner   z
Any | NonerE  npt.NDArray[np.intp])r   r1   rE  z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r   r<   rE  rJ  )r   r   r  rF  )r   rF  )rC   r   rE  ru   )rE  r1   )r   	list[str]r  rF  rE  rK  )rE  znpt.NDArray[np.object_]N)r/  r<   rE  r<   )rE  z
np.ndarray)=r{   
__module____qualname___typ__annotations___can_hold_stringsr.   	_data_clsr   classmethodr   r/   textwrapdedentr   rZ   r   r   r   r   r   r   propertyr   r1   r   __doc__r   r   r   r   r   r   r   r   r2   _index_doc_kwargsr   r   r   r  _requires_unique_msgr  r  r	   
no_defaultr  r  r   r   r  r  r!  r  r)  r2  r,  r-  r@  rC  __classcell__)r
  s   @rS   r<   r<      s   \ D "&&OI "!%, 	,
 , , , 
,. m,$#HOO:
 (
	
. -4"1 *1 	1
 1 1 
1) *1 m,$#HOO:
 (
	
0 &-"1 #	1
 1 1 1 
1) *1 m,$#HOO:
 (
	
. "
/ 
/ 	
/
 
/ 
/ 

/) *
/ = =
2 X X9   e  (()V *V 2 2  . /+ /+b)0?B<< 9=H%H	!HZ "  $,, , 	,
 , 
,6  !9:=NNOJJ	:J PJ<
JJ	:J@ F F 	V 9 5 5 >A^^ H3 2 2 3 3 1 1 4 4G
 tV	 VF(",>
RrU   c                n    t        t        |       t        | t              t        | t              | du g      S )zJ
    Helper for interval_range to check if start/end are valid types.
    N)anyr'   rJ   r   r   )endpoints    rS   _is_valid_endpointr_    s:     hx+x+		
 rU   c                    d }d }t        |       xr t        |      xs>  ||       xr  ||      xs*  ||       xr  ||      xs t        j                  | |      S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                .    t        | t        t        f      S rL  )rJ   r   r   xs    rS   <lambda>z%_is_type_compatible.<locals>.<lambda>      ZIz+BC rU   c                .    t        | t        t        f      S rL  )rJ   r   r   rb  s    rS   rd  z%_is_type_compatible.<locals>.<lambda>  re  rU   )r'   comany_none)abis_ts_compatis_td_compats       rS   _is_type_compatiblerm    sc     DLCL	1	&)A, 	O/Q	O/Q	 <<1	rU   c                   t        |       } t        |      }| | n|}|&t        j                  || |      rt        |      rdnd}t        j                  | |||      dk7  rt        d      t        |       st        d|        t        |      st        d|       t        |      rt        |      }nt        |      s|t        d|       |t        |      s	 t        |      }t        t        | |      t        | |      t        ||      g      st        d
      ||dz  }t        |      rt        j                  | ||      r||| z
  |z  z  }|t        || z
  |z        dz   }n| ||dz
  |z  z
  } n|| |dz
  |z  z   }t        j                   | ||      }t        d t        j"                  | ||      D              rOt%        |t        j&                  d            }n/t)        |t*              rt-        | |||      }nt/        | |||      }t0        j3                  |||      S # t
        $ r}t        d	|       |d}~ww xY w)aP  
    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, 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, 2017-01-02], (2017-01-02, 2017-01-03],
                   (2017-01-03, 2017-01-04]],
                  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, 2017-02-01], (2017-02-01, 2017-03-01],
                   (2017-03-01, 2017-04-01]],
                  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]')
    NrE   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 zperiods must be a number, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatiblec              3  2   K   | ]  }t        |        y wrL  )r#   ).0rc  s     rS   	<genexpr>z!interval_range.<locals>.<genexpr>e  s     Ez!}Es   int64)r   endperiodsfreq)r@   rq   )r   rg  rh  r'   count_not_noner   r_  r!   rG  r#   rO   r   allrm  all_not_nonerK   linspacenot_noner   rC   rJ   r   r6   r;   r<   r   )	r   ru  rv  rw  r@   rq   r^  r   r   s	            rS   interval_ranger}    sy   | #5)E
 
%C)usH|WeS9h'qS
%gt494
 	

 e$GwOPP$EcUKLLg, W%88	BCC	$	T?D s+t,T*	
 EFF 1 E3-C%K4''C ?3;4/014G]7Q;$..E[7Q;$..CUC1Ecll5#t&DEE ,!F h	*egDQF$5c7QUVF$$V$v$FFi  	I$P	s   H* *	I3IIrH  )NNNNNr   )r@   r   rq   r   rE  r<   )drW  
__future__r   operatorr   r   rT  typingr   r   r   numpyrK   pandas._libsr	   pandas._libs.intervalr
   r   r   pandas._libs.tslibsr   r   r   r   pandas._typingr   r   r   r   pandas.errorsr   pandas.util._decoratorsr   r   pandas.util._exceptionsr   pandas.core.dtypes.castr   r   r   r   pandas.core.dtypes.commonr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   pandas.core.dtypes.dtypesr*   pandas.core.dtypes.missingr+   pandas.core.algorithmsr-   pandas.core.arrays.intervalr.   r/   pandas.core.commoncorecommonrg  pandas.core.indexersr0   pandas.core.indexes.baseindexesbaseibaser1   r2   r3   r4   pandas.core.indexes.datetimesr5   r6   pandas.core.indexes.extensionr7   r8   pandas.core.indexes.multir9   pandas.core.indexes.timedeltasr:   r;   dictrX  updaterU  rT   rW   r]   r<   r_  rm  r}  rY   rU   rS   <module>r     s     "     
   , 6     4 < ) !   : ( (  1
 001     #<
	
UU  
'" S!&) 6#HOO
< k*ME	  .9=PTUiRN iR V F=ZiR\ 	!(lG
 lG lG lGrU   