
    `Vg                       d dl mZ d dlmZ d dlZd dlmZ d dlmZm	Z	m
Z
mZmZmZmZ d dlZd dlZd dlmZmZ d dl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" d dl#m$Z$ d dl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, d dl-m.Z. d dl/m0Z0 d dl1m2Z2 d dl3m4c m5Z6 d dl7m8Z8 d dl9m4c m:c m;Z< d dl9m=Z= d dl>m?Z?m@Z@mAZA d dlBmCZC erd dlDmEZE  eFd       ZG G d deA      ZHy)    )annotations)	timedeltaN)	getsizeof)TYPE_CHECKINGAnyCallableHashableIteratorListcast)indexlib)unique_deltas)
no_default)Dtypenpt)function)cache_readonlydoc)find_stack_level)ensure_platform_intensure_python_intis_float
is_integer	is_scalaris_signed_integer_dtypeis_timedelta64_dtype)ABCTimedeltaIndex)ops)resolve_na_sentinel)extract_array)maybe_extract_name)Float64Index
Int64IndexNumericIndex)unpack_zerodim_and_defer)Indexc                  l    e Zd ZU dZdZedfZded<   dZded<   e	dEd	       Z
	 	 	 	 	 	 dF	 	 	 	 	 	 	 dGd
Ze	 dH	 	 	 	 	 dId       ZedJdKd       ZedLd       ZedMd       Zd Zd Zd ZdJdZdNdZdZe	dOd       Ze	dOd       Ze	dOd       Ze	dOd       Ze	dOd       Ze	dOd       ZedOd       ZdPdQdZe	dRd       Z e	dSd       Z!edSd       Z"edSd        Z#dTd!Z$e	dUd"       Z% e&e'jP                        dH fd#	       Z(	 	 	 dV	 	 	 	 	 	 	 dW fd$Z)dXd%Z* e&e'jV                        dYd&       Z+ e&e'jX                        e-fdZd'       Z,d[d(Z. e&e'j^                        	 	 	 	 d\	 	 	 	 	 d]d)       Z/d^d*Z0d_d`d+Z1d_d`d,Z2dad-Z3de4jZ                  e4jZ                  f	 	 	 	 	 	 	 dbd.Z5dc fd/Z6	 	 	 	 dd	 	 	 	 	 	 	 de fd0Z7dPdf fd1Z8dgd2Z9dhd3Z:did4Z;df fd5Z<dJ fd6	Z=dHdj fd7Z>dk fd8Z?dl fd9Z@dm fd:ZAdOd;ZBe	dOd<       ZC fd=ZDdnd>ZE eFd?       fd@       ZGdSdAZHdSdBZI fdCZJ fdDZK xZLS )o
RangeIndexa  
    Immutable Index implementing a monotonic integer range.

    RangeIndex is a memory-saving special case of Int64Index limited to
    representing monotonic ranges. Using RangeIndex may in some instances
    improve computing speed.

    This is the default index type used
    by DataFrame and Series when no explicit index is provided by the user.

    Parameters
    ----------
    start : int (default: 0), range, or other RangeIndex instance
        If int and "stop" is not given, interpreted as "stop" instead.
    stop : int (default: 0)
    step : int (default: 1)
    dtype : np.int64
        Unused, accepted for homogeneity with other index types.
    copy : bool, default False
        Unused, accepted for homogeneity with other index types.
    name : object, optional
        Name to be stored in the index.

    Attributes
    ----------
    start
    stop
    step

    Methods
    -------
    from_range

    See Also
    --------
    Index : The base pandas Index type.
    Int64Index : Index of int64 data.
    
rangeindexzsigned integerrange_rangeFbool(_is_backward_compat_public_numeric_indexc                "    t         j                  S N)libindexInt64Engineselfs    Z/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/indexes/range.py_engine_typezRangeIndex._engine_typeo   s    ###    c                   | j                  |       t        |||       }t        |t              r|j	                  |      S t        |t
              r| j                  ||      S t        j                  |||      rt        d      |t        |      nd}|d|}}nt        |      }|t        |      nd}|dk(  rt        d      t        |||      }| j                  ||      S )Nnamez,RangeIndex(...) must be called with integersr      zStep must not be zero)_validate_dtyper"   
isinstancer)   copyr+   _simple_newcomall_none	TypeErrorr   
ValueError)clsstartstopstepdtyper>   r:   rngs           r5   __new__zRangeIndex.__new__v   s     	E"!$s3 eZ(::4:((u%??5t?44 <<tT*JKK,1,=!%(1<U4E$T*D*.*: &19455E4&s..r7   c                    t        |t              s$t        | j                   dt	        |       d      | j                  |       | j                  ||      S )zl
        Create RangeIndex from a range object.

        Returns
        -------
        RangeIndex
        z7(...) must be called with object coercible to a range, z was passedr9   )r=   r+   rB   __name__reprr<   r?   )rD   datar:   rH   s       r5   
from_rangezRangeIndex.from_range   s\     $&<<. !t*[2  	E"t$//r7   c                    t         j                  |       }t        |t              sJ ||_        ||_        i |_        |j                          |S r0   )objectrJ   r=   r+   r,   _name_cache_reset_identity)rD   valuesr:   results       r5   r?   zRangeIndex._simple_new   sF    $&%((( r7   c                    t         S )z(return the class to use for construction)r$   r3   s    r5   _constructorzRangeIndex._constructor   s
     r7   c                    t        j                  | j                  | j                  | j                  t         j
                        S )z
        An int array that for performance reasons is created only when needed.

        The constructed array is saved in ``_cache``.
        rH   )nparangerE   rF   rG   int64r3   s    r5   _datazRangeIndex._data   s)     yyTYY		JJr7   c                l    | j                   }d|j                  fd|j                  fd|j                  fgS )z,return a list of tuples of start, stop, steprE   rF   rG   )r,   rE   rF   rG   r4   rI   s     r5   _get_data_as_itemszRangeIndex._get_data_as_items   s3    kk#))$vsxx&86388:LMMr7   c                    d| j                   i}|j                  t        | j                                      t        j
                  t        |       |fd fS )Nr:   )r:   updatedictra   ibase
_new_Indextype)r4   ds     r5   
__reduce__zRangeIndex.__reduce__   sE    TYY	d--/01$t*a$66r7   c                    | j                         }| j                  0|j                  dt        j                  | j                        f       |S )zH
        Return a list of tuples of the (attr, formatted_value)
        r:   )ra   r:   appendre   default_pprint)r4   attrss     r5   _format_attrszRangeIndex._format_attrs   sA     '')99 LL&%"6"6tyy"ABCr7   c                     y r0    )r4   r:   s     r5   _format_datazRangeIndex._format_data   s    r7   c                   t        | j                        s|S t        | j                  d         }t        | j                  d         }t        t        |      t        |            }|| j                  D cg c]
  }|d| d c}z   S c c}w )Nr   < )lenr,   strmax)r4   headerna_repfirst_val_strlast_val_str
max_lengthxs          r5   _format_with_headerzRangeIndex._format_with_header   sz    4;;MDKKN+4;;r?+]+S->?
t{{C!Aa
|0^,-CCCCs   5B	z^RangeIndex.{} is deprecated and will be removed in a future version. Use RangeIndex.{} insteadc                .    | j                   j                  S )zV
        The value of the `start` parameter (``0`` if this was not supplied).
        )r,   rE   r3   s    r5   rE   zRangeIndex.start   s     {{   r7   c                    t        j                  | j                  j                  dd      t        t                      | j                  S )z
        The value of the `start` parameter (``0`` if this was not supplied).

         .. deprecated:: 0.25.0
            Use ``start`` instead.
        _startrE   
stacklevel)warningswarn_deprecation_messageformatFutureWarningr   rE   r3   s    r5   r   zRangeIndex._start   s;     	%%,,Xw?')	

 zzr7   c                .    | j                   j                  S )z4
        The value of the `stop` parameter.
        )r,   rF   r3   s    r5   rF   zRangeIndex.stop  s    
 {{r7   c                    t        j                  | j                  j                  dd      t        t                      | j                  S )zw
        The value of the `stop` parameter.

         .. deprecated:: 0.25.0
            Use ``stop`` instead.
        _stoprF   r   )r   r   r   r   r   r   rF   r3   s    r5   r   zRangeIndex._stop  ;     	%%,,Wf=')	

 yyr7   c                .    | j                   j                  S )zU
        The value of the `step` parameter (``1`` if this was not supplied).
        )r,   rG   r3   s    r5   rG   zRangeIndex.step%  s     {{r7   c                    t        j                  | j                  j                  dd      t        t                      | j                  S )z
        The value of the `step` parameter (``1`` if this was not supplied).

         .. deprecated:: 0.25.0
            Use ``step`` instead.
        _steprG   r   )r   r   r   r   r   r   rG   r3   s    r5   r   zRangeIndex._step-  r   r7   c                \    | j                   t              t        fddD              z   S )zD
        Return the number of bytes in the underlying data.
        c              3  H   K   | ]  }t        t        |              y wr0   )r   getattr).0	attr_namerI   s     r5   	<genexpr>z$RangeIndex.nbytes.<locals>.<genexpr>C  s%      $
 gc9-.$
s   ")rE   rF   rG   )r,   r   sumr`   s    @r5   nbyteszRangeIndex.nbytes=  s3    
 kk~ $
6$
 !
 
 	
r7   c                    | j                   S )a  
        Memory usage of my values

        Parameters
        ----------
        deep : bool
            Introspect the data deeply, interrogate
            `object` dtypes for system-level memory consumption

        Returns
        -------
        bytes used

        Notes
        -----
        Memory usage does not include memory consumed by elements that
        are not components of the array if deep=False

        See Also
        --------
        numpy.ndarray.nbytes
        )r   )r4   deeps     r5   memory_usagezRangeIndex.memory_usageH  s    . {{r7   c                H    t        j                  t         j                        S r0   )r[   rH   r]   r3   s    r5   rH   zRangeIndex.dtypea  s    xx!!r7   c                     y)z%return if the index has unique valuesTrp   r3   s    r5   	is_uniquezRangeIndex.is_uniquee  s     r7   c                T    | j                   j                  dkD  xs t        |       dk  S Nr   r;   r,   rG   rv   r3   s    r5   is_monotonic_increasingz"RangeIndex.is_monotonic_increasingj  $    {{!#5s4yA~5r7   c                T    | j                   j                  dk  xs t        |       dk  S r   r   r3   s    r5   is_monotonic_decreasingz"RangeIndex.is_monotonic_decreasingn  r   r7   c                j    t        |       	 t        |      }|| j                  v S # t        $ r Y yw xY w)NF)hashr   rB   r,   )r4   keys     r5   __contains__zRangeIndex.__contains__r  s=    S		#C(C dkk!!  		s   & 	22c                     y)Nintegerrp   r3   s    r5   inferred_typezRangeIndex.inferred_typez  s    r7   c                <   |k|it        |      st        |      r7|j                         r't        |      }	 | j                  j	                  |      S | j                  |       t        |      t        | %  |||      S # t
        $ r}t        |      |d }~ww xY w)N)method	tolerance)
r   r   intr,   r   rC   KeyError_check_indexing_errorsuperget_loc)r4   r   r   r   new_keyerr	__class__s         r5   r   zRangeIndex.get_loc  s    >i/#8C=S^^5Ec(1;;,,W55 &&s+3-ws6YGG	 " 1"3-S01s   B 	B
BBc                   t        j                  |||      rt        |   ||||      S | j                  dkD  r%| j
                  | j                  | j                  }}}n6| j                  d d d   }|j
                  |j                  |j                  }}}t        j                  |      }	|	|z
  }
|
|z  dk(  |
dk\  z  |	|k  z  }d|
| <   |
|   |z  |
|<   || j                  k7  rt        |       dz
  |
|   z
  |
|<   t        |
      S )N)r   r   limitr   rs   r;   )r@   any_not_noner   _get_indexerrG   rE   rF   r,   r[   asarrayrv   r   )r4   targetr   r   r   rE   rF   rG   reversetarget_arraylocsvalidr   s               r5   r   zRangeIndex._get_indexer  s    FIu57'v% (   99q= $

DIItyy4E kk$B$'G 'w||W\\4Ezz&)e#!dai0L44GHeV5kD(U499d)a-$u+5DK"4((r7   c                ,    t        | j                        S r0   )listr,   r3   s    r5   tolistzRangeIndex.tolist  s    DKK  r7   c              #  8   K   | j                   E d {    y 7 wr0   r,   r3   s    r5   __iter__zRangeIndex.__iter__  s     ;;s   c                X   |t         u r| j                  n|}|j                  j                  dk(  rt	        ||      S t        |      }t        |      dk(  r?|d   dk7  r7|d   }t        |d   |d   |z   |      }t        |       j                  ||      S t        j                  ||      S )Nfr9   r;   r   rs   )r   r:   rH   kindr#   r   rv   r+   rg   r?   r$   )r4   rU   r:   unique_diffsdiff	new_ranges         r5   _shallow_copyzRangeIndex._shallow_copy  s     J.tyyD<<#T22 %V,|!l1o&:?DfQid):DAI:)))$)??))&t<<r7   c                    t        |       j                  | j                  | j                        }| j                  |_        |S )Nr9   )rg   r?   r,   rR   rS   )r4   rV   s     r5   _viewzRangeIndex._view  s3    d''$**'Er7   c                    | j                  |||      d   }| j                  |      }|r5t        j                  dt        t                      |j                  |      }|S )N)r:   namesr   r   r9   zeparameter dtype is deprecated and will be removed in a future version. Use the astype method instead.r   )_validate_names_renamer   r   r   r   astype)r4   r:   r   rH   r   	new_indexs         r5   r>   zRangeIndex.copy  se     ##U#FqILLdL+	MM:+-	 "((/Ir7   c                    t        |       dz
  }|dk(  rt        j                  S |dk(  r| j                  dkD  s|dk(  r| j                  dk  r| j                  S | j                  | j                  |z  z   S )Nr;   rs   minr   rx   )rv   r[   nanrG   rE   )r4   methno_stepss      r5   _minmaxzRangeIndex._minmax  sc    t9q=r>66Mem		A45=TYYQR]::zzDII000r7   c                z    t        j                  |       t        j                  ||       | j                  d      S )z#The minimum value of the RangeIndexr   )nvvalidate_minmax_axisvalidate_minr   r4   axisskipnaargskwargss        r5   r   zRangeIndex.min  -    
%
f%||E""r7   c                z    t        j                  |       t        j                  ||       | j                  d      S )z#The maximum value of the RangeIndexrx   )r   r   validate_maxr   r   s        r5   rx   zRangeIndex.max  r   r7   c                   |j                  dd      }|j                  dd       t        j                  ||       | j                  j                  dkD  r/t        j                  t        |       t
        j                        }n3t        j                  t        |       dz
  ddt
        j                        }|s|ddd   }|S )	z
        Returns the indices that would sort the index and its
        underlying data.

        Returns
        -------
        np.ndarray[np.intp]

        See Also
        --------
        numpy.ndarray.argsort
        	ascendingTr   Nr   rZ   r;   rs   )	popr   validate_argsortr,   rG   r[   r\   rv   intp)r4   r   r   r   rV   s        r5   argsortzRangeIndex.argsort  s     JJ{D1	

64 
D&);;aYYs4y8FYYs4y1}b"BGGDFDbD\Fr7   c                    t        ||       t        j                  t        |       t        j                        }| }|r| j
                  dk  r|d d d   }|d d d   }||fS )NrZ   r   rs   )r    r[   r\   rv   r   rG   )r4   sortna_sentineluse_na_sentinelcodesuniquess         r5   	factorizezRangeIndex.factorize  s\     	K9		#d)2773DIIM$B$KEddmGg~r7   c                t    t        |t              r| j                  |j                  k(  S t        |   |      S )zL
        Determines if two Index objects contain the same elements.
        )r=   r)   r,   r   equals)r4   otherr   s     r5   r   zRangeIndex.equals  s1     eZ(;;%,,..w~e$$r7   c                   | }t        t        t        |                   }|t        |   ||||      S | }|r | j
                  dk  r2| d d d   }|d d d   }n!| j
                  dkD  r| d d d   }|d d d   x}}|r||fS |S )N)return_indexerr   na_positionr   r   rs   )r)   r+   rv   r   sort_valuesrG   )r4   r   r   r   r   sorted_indexindexerr   s          r5   r   zRangeIndex.sort_values%  s     U3t9-.?7&-#'	 '    L99q=#'":L%ddmG99q=#'":L(/"5Gg((r7   c                f   t        |t              st        |   ||      S | j                  dk  r| j
                  d d d   n| j
                  }|j                  dk  r|j
                  d d d   n|j
                  }t        |j                  |j                        }t        |j                  |j                        }||k  r| j                  t              S | j                  |j                  |j                        \  }}}	|j                  |j                  z
  |z  r| j                  t              S |j                  |j                  |j                  z
  |j                  z  |z  |z  z   }
|j                  |j                  z  |z  }t        |
||      }| j                  |      }|j                  |      }t        ||j                  |j                        }| j                  |      }| j                  dk  xr |j                  dk  |j                  dk  ur|d d d   }||j                         }|S )Nr   r   rs   )r=   r)   r   _intersectionrG   r,   rx   rE   r   rF   r?   _empty_range_extended_gcdr+   _min_fitting_elementr   )r4   r   r   firstsecondint_lowint_highgcds_	tmp_startnew_stepr   r   	new_startr   s                  r5   r  zRangeIndex._intersectionH  s    %,7(T(::%)YY]DbD!',zzA~dd#5<< ekk6<<0uzz6;;/w##L11 &&uzz6;;?	Q KK&,,&#-##L11 KK6<<%++#="Ks"RUV"VV	::+s2)Xx8	$$Y/	 227;	)Y^^Y^^D	$$Y/	IIM,ejj1ninnq6HI!$B$I<!--/Ir7   c                    || j                   z
   t        | j                        z   }| j                   t        | j                        |z  z   S )z?Returns the smallest element greater than or equal to the limit)rE   absrG   )r4   lower_limitr   s      r5   r  zRangeIndex._min_fitting_elementw  s?    "TZZ/0C		NBCzzC		NX555r7   c                x    d\  }}d\  }}||}}|r&||z  }	|||	|z  z
  }}|||	|z  z
  }}|||	|z  z
  }}|r&|||fS )z
        Extended Euclidean algorithms to solve Bezout's identity:
           a*x + b*y = gcd(x, y)
        Finds one particular solution for x, y: s, t
        Returns: gcd, s, t
        )r   r;   )r;   r   rp   )
r4   abr
  old_stold_trold_rquotients
             r5   r  zRangeIndex._extended_gcd|  su     55a5zH%(Q,.1E%(Q,.1E%(Q,.1E	 
 eU""r7   c                    |sy| j                   syt        |      dkD  r$|j                  | j                   j                  z  ry|j                  | j                   v xr |d   | j                   v S )z)Check if other range is contained in selfTFr;   rs   )r,   rv   rG   rE   )r4   r   s     r5   _range_in_selfzRangeIndex._range_in_self  s\     {{u:>ejj4;;+;+;;{{dkk)FeBi4;;.FFr7   c                   t        |t              rM|1|du rF| j                  dkD  r6| j                  |j                        r| j
                  | j                  }}| j
                  | j                  t        |       dz
  z  z   }|j
                  |j                  }}|j
                  |j                  t        |      dz
  z  z   }| j                  dk  r|| |}}}|j                  dk  r|| |}}}t        |       dk(  r3t        |      dk(  r%t        | j
                  |j
                  z
        x}}n!t        |       dk(  r|}nt        |      dk(  r|}t        ||      }	t        ||      }
||k(  r}||z
  |z  dk(  r&||z
  |k  r||z
  |k  r t        |       |	|
|z   |      S |dz  dk(  rt        ||z
        |dz  k(  rt        ||z
        |dz  k(  r t        |       |	|
|dz  z   |dz        S ||z  dk(  r1||z
  |z  dk(  r_||z   |k\  rW||z
  |k  rO t        |       |	|
|z   |      S ||z  dk(  r1||z
  |z  dk(  r&||z   |k\  r||z
  |k  r t        |       |	|
|z   |      S t        | 1  ||      S )a  
        Form the union of two Index objects and sorts if possible

        Parameters
        ----------
        other : Index or array-like

        sort : False or None, default None
            Whether to sort (monotonically increasing) the resulting index.
            ``sort=None`` returns a ``RangeIndex`` if possible or a sorted
            ``Int64Index`` if not.
            ``sort=False`` can return a ``RangeIndex`` if self is monotonically
            increasing and other is fully contained in self. Otherwise, returns
            an unsorted ``Int64Index``

            .. versionadded:: 0.25.0

        Returns
        -------
        union : Index
        Fr   r;      r   )r=   r)   rG   r  r,   rE   rv   r  r   rx   rg   r   _union)r4   r   r   start_sstep_send_sstart_ostep_oend_ostart_rend_rr   s              r5   r  zRangeIndex._union  s   , eZ(|$))a-D4G4G4U #'**dii

TYY#d)a-%@@"'++uzzejjCJN&CC99q=-2VGWUVG::>-2VGWUVGt9>c%jAo&)$**u{{*B&CCFVY!^#FZ1_#Fgw/E5)V# 7*f49$u_7$u_7)tDz'56>6JJ!q 7!23vzA /6A:=  *tDz'56A:3EvPQzRRf_) 7*f49$v-8"V^u4)tDz'56>6JJf_) 7*f49$v-8"V^u4)tDz'56>6JJw~e$~//r7   c                   | j                  |       | j                  |       | j                  |      \  }}t        |t              st
        
|   ||      S |&| j                  dk  r| d d d   j                  |      S t        j                  | |      }| j                  dk  r| j                  d d d   n| j                  }| j                  |      }|j                  dk  r|d d d   }t        |      dk(  r| j                  |      S t        |      t        |       k(  r| d d j                  |      S t        |      dk(  rR|d   | d   k(  r| dd  S |d   | d   k(  r| d d S t        |       dk(  r|d   | d   k(  r| d d d   S t
        
|   ||      S t        |      dk(  r|d   |d   k(  r|d   |d   k(  r| dd S |j                  |j                  k(  r|d   |j                  k(  r2t        |d   |j                  z   |j                   |j                        }n|d   |d   k(  r%t        |j                  |d   |j                        }n|j                  |dd k(  rt        |      dz
  }|d d |   }nt
        
|   ||      S t        |       dkD  sJ |j                  |j                  dz  k(  rW|d   |d   k(  r|d   |d   |d   fv r	|dd d   }nE|d   |d   k(  r|d   |d   |d   fv r	|d d d   }n"t
        
|   ||      S t
        
|   ||      S t#        |       j%                  ||      }	|| j                  ur|	d d d   }	|	S )	Nr   r   rs   r9   r;      r  )_validate_sort_keyword_assert_can_do_setop_convert_can_do_setopr=   r)   r   _differencerG   r   get_op_result_namer,   intersectionrv   renamerE   r+   rF   rg   r?   )r4   r   r   result_nameres_namer  overlapnew_rngrG   r   r   s             r5   r.  zRangeIndex._difference  s~   ##D)!!%(!77>{%,7&u4&88<DIIM":))%00))$6%)YY]DbD!##E*<<!ddmGw<1;;H;--w<3t9$8??8,, w<1qzT!W$ABxtBx'CRy TaGAJ$q'$9CaCy  w*5t*<<\Q71:q#9gbkUSUY>V":<<5::%qzU[[(ejj 8%**ejjQb	)WQZD52;.5zA~$- w*5t*<<
 t9q= =||uzzA~-1:q)gbkeBir=S.S#ADqDkGQZ58+b	5QS9?U0U#CaCjG !7.u4.@@ w*5t*<<J**7*B	#!$B$Ir7   c                    t        |t              r|t        |   |||      S | j	                  |      }|j	                  |       }|j                  |      }||j                  |      }|S r0   )r=   r)   r   symmetric_difference
differenceunionr1  )r4   r   r2  r   leftrightrV   r   s          r5   r7  zRangeIndex.symmetric_difference<  sk    %,0@7/{DIIu%  &E""]];/Fr7   c                   t        |      rT|dk(  s|t        |        k(  r| dd  S |dk(  s|t        |       dz
  k(  r| d d S t        |       dk(  r|dk(  s|dk(  r| d d d   S t        j                  |      rjt        j                  t        j                  |t
        j                        t        |             }t        |t              r| |   }| j                  |d	      S t        | 1  |      S )
Nr   r;   rs   r)  r*  r  rZ   Fr   )r   rv   r   is_list_likemaybe_indices_to_slicer[   r   r   r=   slicer8  r   delete)r4   locslcr   r   s       r5   r@  zRangeIndex.deleteL  s     c?ax33t9*,ABxbyC3t9q=0CRy 4yA~3!8sbyCaCy c",,RZZ277-KSQUYWC#u% S	u599w~c""r7   c                ~   t        |       rt        |      st        |      r| j                  }|dk(  rs|| d   | j                  z
  k(  r^t        |j                  |j                  z
  |j                  |j                        }t        |       j                  || j                        S |t        |       k(  rs|| d   | j                  z   k(  r^t        |j                  |j                  |j                  z   |j                        }t        |       j                  || j                        S t        |       dk(  rw|| d   | j                  dz  z   k(  r_t        | j                  dz        }t        | j                  | j                  |      }t        |       j                  || j                        S t        | 5  ||      S )Nr   r9   rs   r  )rv   r   r   r,   rG   r+   rE   rF   rg   r?   r:   r   r   insert)r4   rA  itemrI   r5  rG   r   s         r5   rD  zRangeIndex.insertb  sY   t9*T*htn ++CaxDDGdii$77		CHH 4chhIDz--gDII-FFD	!dd2h.B&B		388chh+>IDz--gDII-FFTaDDGdii!m,C$C499q=)

DIIt<Dz--gDII-FFw~c4((r7   c           	        t        d |D              st        | 	  ||      S t        |      dk(  r|d   S t	        t
        t           |      }dx}x}}|D cg c]  }t        |      s| }}|D ]2  }|j                  }	|)|	j                  }|t        |	      dkD  rx|	j                  }nk|i|	j                  |k(  rKt        j                  |D 
cg c]  }
|
j                   c}
      }t        |      }|j                  |      c S |	j                  |z
  }||	j                  k7  xr t        |	      dkD  xs |duxr |	j                  |k7  }|rIt        t        j                  |D 
cg c]  }
|
j                   c}
            }|j                  |      c S |+|	d   |z   }5 |r/||d   j                  n|}t        |||      j                  |      S t        dd      j                  |      S c c}w c c}
w c c}
w )ar  
        Overriding parent method for the case of all RangeIndex instances.

        When all members of "indexes" are of type RangeIndex: result will be
        RangeIndex if possible, Int64Index otherwise. E.g.:
        indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)
        indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Int64Index([0,1,2,4,5])
        c              3  <   K   | ]  }t        |t                y wr0   )r=   r)   r   r~   s     r5   r   z%RangeIndex._concat.<locals>.<genexpr>  s     >:a,>s   r;   r   Nrs   )allr   _concatrv   r   r   r)   r,   rE   rG   r[   concatenate_valuesr$   r1  rF   )r4   indexesr:   rng_indexesrE   rG   next_objnon_empty_indexesrI   r~   rU   rV   non_consecutiverF   r   s                  r5   rJ  zRangeIndex._concatw  s    >g>>7?7D11\Q1:4
+W5###u -8DS3s8SDD$ 	'C**C}		<CHqL88D99%^^,L1QYY,LMF'/F!==..yy5(#sxx/@CHqL T!8cii5&8  #BNN{3S!AII3S$TU}}T**B$3	'6  27$R(--EDeT4077== !Q&&t,,K E -M 4Ts   G3)G3G8
'G=c                ,    t        | j                        S )z5
        return the length of the RangeIndex
        )rv   r,   r3   s    r5   __len__zRangeIndex.__len__  s     4;;r7   c                    t        |       S r0   )rv   r3   s    r5   sizezRangeIndex.size  s    4yr7   c           	     j   t        |t              r,| j                  |   }| j                  || j                        S t        |      rt        |      }	 | j                  |   S t        |      rt        d      t        | -  |      S # t        $ r }t        d| dt        |              |d}~ww xY w)zE
        Conserve RangeIndex type for scalar and slice keys.
        r9   zindex z' is out of bounds for axis 0 with size Nzuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices)r=   r?  r,   r?   rR   r   r   
IndexErrorrv   r   r   __getitem__)r4   r   r   r   r   r   s        r5   rY  zRangeIndex.__getitem__  s     c5!C(I##IDJJ#??_#hG{{7++
 s^+  w"3''   SE!HTTs   B	 		B2B--B2c                l    | j                   |   }t        |       j                  || j                        S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r9   )r,   rg   r?   rR   )r4   slobjress      r5   _getitem_slicezRangeIndex._getitem_slice  s0     kk% Dz%%c

%;;r7   __floordiv__c                   t        |      r|dk7  rt        |       dk(  s$| j                  |z  dk(  ro| j                  |z  dk(  r]| j                  |z  }| j                  |z  }|t        |       |z  z   }t	        |||xs d      }| j                  || j                        S t        |       dk(  r<| j                  |z  }t	        ||dz   d      }| j                  || j                        S t        | !  |      S )Nr   r;   r9   )	r   rv   rE   rG   r+   r?   r:   r   r^  )r4   r   rE   rG   rF   r   r   s         r5   r^  zRangeIndex.__floordiv__  s     e!4yA~e!3q!8TYY=NRS=S

e+yyE)s4y4//!%tyq9	''			'BB4yA~

e+!%A6	''			'BBw#E**r7   c                    d| j                   vS )Nr   r   r4   r   r   s      r5   rI  zRangeIndex.all  s    ##r7   c                ,    t        | j                        S r0   )anyr,   ra  s      r5   rc  zRangeIndex.any  s    4;;r7   c                    t        |t              r)| j                  |j                  k(  rt        |   | |      S t        |   ||      S r0   )r=   r)   r,   r   _cmp_method)r4   r   opr   s      r5   re  zRangeIndex._cmp_method  s@    eZ(T[[ELL-H7&tR00w"5"--r7   c           	        t        |t              rt        S t        |t        t        j
                  f      rt        |   ||      S t        |      rt        |   ||      S |t        j                  t        j                  t        j                  t        j                  t        j                  t        j                   t"        t        j$                  fv rt        |   ||      S d}|t        j&                  t        j(                  t        j*                  t        j,                  fv r|}t/        |dd      }| }	 |rEt	        j0                  d      5   ||j2                  |      }ddd       t5              r|st6        |j2                  }t	        j0                  d      5   ||j8                  |      } ||j:                  |      }ddd       t        j<                  | |      }	 t?        |       ||	      }
tA        d |||fD              s|
jC                  d      }
|
S # 1 sw Y   xY w# 1 sw Y   hxY w# t6        tD        tF        f$ r t        |   ||      cY S w xY w)	z
        Parameters
        ----------
        other : Any
        op : callable that accepts 2 params
            perform the binary op
        NT)extract_numpyextract_rangeignore)rI  r9   c              3  2   K   | ]  }t        |        y wr0   )r   rH  s     r5   r   z+RangeIndex._arith_method.<locals>.<genexpr>>  s     Ez!}Es   float64)$r=   r   NotImplementedr   r[   timedelta64r   _arith_methodr   operatorpowr   rpowmodrmodfloordiv	rfloordivdivmodrdivmodmulrmultruedivrtruedivr!   errstaterG   r   rC   rE   rF   r/  rg   rI  r   rB   ZeroDivisionError)r4   r   rf  rG   r;  r:  rsteprstartrstopr3  rV   r   s              r5   ro  zRangeIndex._arith_method  s    e./!!	2>>:; 7(33!%(7(33LLHHLLHHMMKK	
 	
 7(33 $(,,(*:*:CLLIID e4tL 	4[[X. 3 E2E3
 "%($$ 		* -DJJ.499e,- --dE:HT$Zu8DF
 Evue.DEEy1M13 3- - I'89 	4 7(33	4sC   :H= H%&=H= #'H1
AH= %H.*H= 1H:6H= =$I$#I$)returnztype[libindex.Int64Engine])NNNNFN)rH   Dtype | Noner>   r-   r:   r	   r  r)   )NN)rN   r+   rH   r  r  r)   r0   )rU   r+   r:   r	   r  r)   )r  ztype[Int64Index])r  z
np.ndarray)ry   	list[str]rz   rw   r  r  )r  r   )F)r   r-   r  r   )r  znp.dtype)r  r-   )r   r   r  r-   )r  rw   )NNN)r   r'   r   z
str | Noner   z
int | Noner  npt.NDArray[np.intp])r  z	list[int])r  zIterator[int])r:   r	   )r4   r)   r  r)   )NFNN)r:   r	   r   r-   rH   r  )r   rw   )NT)r   r-   r  r   )r  r  )r   r-   r   zint | lib.NoDefaultr   zbool | lib.NoDefaultr  z'tuple[npt.NDArray[np.intp], RangeIndex])r   rQ   r  r-   )FTlastN)r   r-   r   r-   r   rw   r   zCallable | None)r   r'   )r  r   r  r   )r  r   r  r   r  ztuple[int, int, int])r   r+   r  r-   )r2  r	   )r  r'   )rA  r   r  r'   )rM  zlist[Index]r:   r	   r  r'   )r4   r)   r[  r?  r  r)   )MrL   
__module____qualname____doc___typr   _dtype_validation_metadata__annotations__r.   propertyr6   rJ   classmethodrO   r?   r   rX   r^   ra   ri   rn   rq   r   r   rE   r   rF   r   rG   r   r   r   rH   r   r   r   r   r   r   r$   r   r   r   r   r   r   r   r>   r   r   rx   r   r   r   r   r   r  r  r  r  r  r.  r7  r@  rD  rJ  rT  rV  rY  r]  r&   r^  rI  rc  re  ro  __classcell__)r   s   @r5   r)   r)   B   s   %N D"9;K!LM5:,d:$ $ ""/
 "/ "/ "/ 
"/H ;?00,80	0 0$ 	 	  
 K KN
7D	  ! !               
 
2 " "   6 6 6 6"   			
H 
H " )) ) 	) 
)@! 			  		!	!"5? = #=
 	 "  	 (1##8 +.>>03	 ) .	
 
1%  %!#     	 
  F-^6
#"	GK0ZUn
 #,)*9-v   (2< n-+ .+&$ 
.H4 H4r7   r)   )I
__future__r   datetimer   rp  sysr   typingr   r   r   r	   r
   r   r   r   numpyr[   pandas._libsr   r1   r   pandas._libs.algosr   pandas._libs.libr   pandas._typingr   r   pandas.compat.numpyr   r   pandas.util._decoratorsr   r   pandas.util._exceptionsr   pandas.core.dtypes.commonr   r   r   r   r   r   r   pandas.core.dtypes.genericr   pandas.corer   pandas.core.algorithmsr    pandas.core.commoncorecommonr@   pandas.core.constructionr!   pandas.core.indexes.baserM  basere   r"   pandas.core.indexes.numericr#   r$   r%   pandas.core.ops.commonr&   pandasr'   r+   r  r)   rp   r7   r5   <module>r     s    "        - ' / 5   9  6     2 ( ( 7 
 <QxD4 D4r7   