
    OwgW                       d dl mZ d dlmZ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 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 d dlmZm Z m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( d dl)m*Z* d dl+m,Z, d dl-m.c m/Z0 d dl1m2Z2 d dl3m.c m4c m5Z6 d dl3m7Z7m8Z8 d dl9m:Z: erd dl;m<Z<m=Z=m>Z>m?Z?m@Z@  eAd       ZB ej                  ej                        ZE G d de7      ZFy)    )annotations)HashableIterator)	timedeltaN)	getsizeof)TYPE_CHECKINGAnyCallableLiteralcastoverload)indexlib)unique_deltas)
no_default)function)cache_readonlydeprecate_nonkeyword_argumentsdoc)ensure_platform_intensure_python_intis_float
is_integer	is_scalaris_signed_integer_dtype)ABCTimedeltaIndex)ops)extract_array)Indexmaybe_extract_name)unpack_zerodim_and_defer)AxisDtype
NaPositionSelfnptc                      e Zd ZU dZdZedfZded<   ded<   edLd       Z		 	 	 	 	 	 dM	 	 	 	 	 	 	 dNd	Z
edOdPd
       Ze	 dQ	 	 	 	 	 dRd       ZedSd       ZedTd       ZedUd       ZdVdZd Zd ZdWdZedXd       ZedXd       ZedXd       ZedXd       ZdYdZdZed[d       Zed\d       Zed\d       Zed\d       Zd]dZed^d       Z  e!e"jF                        dXd       Z#	 	 	 d_	 	 	 	 	 	 	 d` fdZ$ed\d        Z%dad!Z& e!e"jN                        dbd"       Z' e!e"jP                        e)fdcd#       Z(ddd$Z* e!e"jV                        dedfd%       Z+dgd&Z,dhdid'Z-dhdid(Z.djd)Z/	 	 dk	 	 	 	 	 dld*Z0dm fd+Z1e2d,d,d,d,d-	 	 	 	 	 	 	 	 	 dnd.       Z3e2d,d,d,d/	 	 	 	 	 	 	 	 	 dod0       Z3e2d,d,d,d,d-	 	 	 	 	 	 	 	 	 dpd1       Z3 e4d2d3gd45      	 	 	 	 dq	 	 	 	 	 	 	 	 	 dp fd6       Z3dYdr fd7Z5dsd8Z6dtd9Z7dud:Z8dv fd;Z9dQ fd<	Z:	 dO	 dw fd=Z;dx fd>Z<dy fd?Z=dz fd@Z>dXdAZ?edXdB       Z@ fdCZAd{dDZB eCdE       fdF       ZDd\dGZEd\dHZF fdIZG fdJZH	 	 	 d|	 	 	 	 	 d}dKZI xZJS )~
RangeIndexaL  
    Immutable Index implementing a monotonic integer range.

    RangeIndex is a memory-saving special case of an Index limited to representing
    monotonic ranges with a 64-bit dtype. 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.

    Examples
    --------
    >>> list(pd.RangeIndex(5))
    [0, 1, 2, 3, 4]

    >>> list(pd.RangeIndex(-2, 4))
    [-2, -1, 0, 1, 2, 3]

    >>> list(pd.RangeIndex(0, 10, 2))
    [0, 2, 4, 6, 8]

    >>> list(pd.RangeIndex(2, -10, -3))
    [2, -1, -4, -7]

    >>> list(pd.RangeIndex(0))
    []

    >>> list(pd.RangeIndex(1, 0))
    []
    
rangeindexzsigned integerrange_range
np.ndarray_valuesc                "    t         j                  S N)libindexInt64Engineselfs    P/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/indexes/range.py_engine_typezRangeIndex._engine_type   s    ###    c                   | j                  |       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    
isinstancecopyr*   _simple_newcomall_none	TypeErrorr   
ValueError)clsstartstopstepdtyper=   r9   rngs           r4   __new__zRangeIndex.__new__   s     	E"!$s3 eS!::4:((u%??5t?44 <<tT*JKK,1,=!%(1<U4E$T*D*.*: &19455E4&s..r6   c                    t        |t              s$t        | j                   dt	        |       d      | j                  |       | j                  ||      S )af  
        Create :class:`pandas.RangeIndex` from a ``range`` object.

        Returns
        -------
        RangeIndex

        Examples
        --------
        >>> pd.RangeIndex.from_range(range(5))
        RangeIndex(start=0, stop=5, step=1)

        >>> pd.RangeIndex.from_range(range(2, -10, -3))
        RangeIndex(start=2, stop=-10, step=-3)
        z7(...) must be called with object coercible to a range, z was passedr8   )r<   r*   rA   __name__reprr;   r>   )rC   datar9   rG   s       r4   
from_rangezRangeIndex.from_range   s\    " $&<<. !t*[2  	E"t$//r6   c                    t         j                  |       }t        |t              sJ ||_        ||_        i |_        |j                          d |_        |S r/   )	objectrI   r<   r*   r+   _name_cache_reset_identity_references)rC   valuesr9   results       r4   r>   zRangeIndex._simple_new   sP     $&%((( !r6   c                Z    |y | j                   \  }} ||      st        d| d|       y )Nz#Incorrect `dtype` passed: expected z, received )_dtype_validation_metadatarB   )rC   rG   validation_funcexpecteds       r4   r;   zRangeIndex._validate_dtype   sD    =$'$B$B!u%5hZ{5'R  &r6   c                    t         S )z(return the class to use for construction)r   r2   s    r4   _constructorzRangeIndex._constructor   s	     r6   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``.
        rG   )nparangerD   rE   rF   int64r2   s    r4   _datazRangeIndex._data   s)     yyTYY		JJr6   c                l    | j                   }d|j                  fd|j                  fd|j                  fgS )z,return a list of tuples of start, stop, steprD   rE   rF   )r+   rD   rE   rF   r3   rH   s     r4   _get_data_as_itemszRangeIndex._get_data_as_items   s3    kk#))$vsxx&86388:LMMr6   c                    d| j                   i}|j                  t        | j                                      t        j
                  t        |       |fd fS )Nr9   )rQ   updatedictre   ibase
_new_Indextype)r3   ds     r4   
__reduce__zRangeIndex.__reduce__   sE    TZZ 	d--/01$t*a$66r6   c                    t        d| j                               }| j                  0|j                  dt	        j
                  | j                        f       |S )zH
        Return a list of tuples of the (attr, formatted_value)
        zlist[tuple[str, str | int]]r9   )r   re   rQ   appendri   default_pprint)r3   attrss     r4   _format_attrszRangeIndex._format_attrs  sI     2D4K4K4MN::!LL&%"6"6tzz"BCDr6   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)r3   headerna_repfirst_val_strlast_val_str
max_lengthxs          r4   _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	c                .    | j                   j                  S )a	  
        The value of the `start` parameter (``0`` if this was not supplied).

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.start
        0

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.start
        2
        )r+   rD   r2   s    r4   rD   zRangeIndex.start  s      {{   r6   c                .    | j                   j                  S )z
        The value of the `stop` parameter.

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.stop
        5

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.stop
        -10
        )r+   rE   r2   s    r4   rE   zRangeIndex.stop*  s     {{r6   c                .    | j                   j                  S )a  
        The value of the `step` parameter (``1`` if this was not supplied).

        Examples
        --------
        >>> idx = pd.RangeIndex(5)
        >>> idx.step
        1

        >>> idx = pd.RangeIndex(2, -10, -3)
        >>> idx.step
        -3

        Even if :class:`pandas.RangeIndex` is empty, ``step`` is still ``1`` if
        not supplied.

        >>> idx = pd.RangeIndex(1, 0)
        >>> idx.step
        1
        )r+   rF   r2   s    r4   rF   zRangeIndex.step;  s    . {{r6   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r/   )r   getattr).0	attr_namerH   s     r4   	<genexpr>z$RangeIndex.nbytes.<locals>.<genexpr>Z  s%      $
 gc9-.$
s   ")rD   rE   rF   )r+   r   sumrd   s    @r4   nbyteszRangeIndex.nbytesT  s3    
 kk~ $
6$
 !
 
 	
r6   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   )r3   deeps     r4   memory_usagezRangeIndex.memory_usage_  s    . {{r6   c                    t         S r/   )_dtype_int64r2   s    r4   rG   zRangeIndex.dtypex  s    r6   c                     y)z%return if the index has unique valuesT r2   s    r4   	is_uniquezRangeIndex.is_unique|  s     r6   c                T    | j                   j                  dkD  xs t        |       dk  S Nr   r:   r+   rF   rw   r2   s    r4   is_monotonic_increasingz"RangeIndex.is_monotonic_increasing  $    {{!#5s4yA~5r6   c                T    | j                   j                  dk  xs t        |       dk  S r   r   r2   s    r4   is_monotonic_decreasingz"RangeIndex.is_monotonic_decreasing  r   r6   c                j    t        |       	 t        |      }|| j                  v S # t        $ r Y yw xY wNF)hashr   rA   r+   )r3   keys     r4   __contains__zRangeIndex.__contains__  s=    S		#C(C dkk!!  		s   & 	22c                     y)Nintegerr   r2   s    r4   inferred_typezRangeIndex.inferred_type  s    r6   c                D   t        |      st        |      r7|j                         r't        |      }	 | j                  j	                  |      S t        |t              rt        |      | j                  |       t        |      # t
        $ r}t        |      |d }~ww xY wr/   )
r   r   intr+   r   rB   KeyErrorr<   r   _check_indexing_error)r3   r   new_keyerrs       r4   get_loczRangeIndex.get_loc  s    c?x}1A#hG-{{((11 c8$3-""3'sm  -sm,-s   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)method	tolerancelimitr   rt   r:   )r?   any_not_nonesuper_get_indexerrF   rD   rE   r+   r_   asarrayrw   r   )r3   targetr   r   r   rD   rE   rF   reversetarget_arraylocsvalid	__class__s               r4   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((r6   c                     y)zA
        Should an integer key be treated as positional?
        Fr   r2   s    r4   _should_fallback_to_positionalz)RangeIndex._should_fallback_to_positional  s    
 r6   c                ,    t        | j                        S r/   )listr+   r2   s    r4   tolistzRangeIndex.tolist  s    DKK  r6   c              #  8   K   | j                   E d {    y 7 wr/   r+   r2   s    r4   __iter__zRangeIndex.__iter__  s     ;;s   c                   |t         u r| j                  n|}|j                  j                  dk(  rt	        ||t
        j                        S t        |      }t        |      dk(  r?|d   dk7  r7|d   }t        |d   |d   |z   |      }t        |       j                  ||      S | j                  j                  ||      S )Nf)r9   rG   r:   r   rt   r8   )r   rQ   rG   kindr   r_   float64r   rw   r*   rk   r>   r\   )r3   rU   r9   unique_diffsdiff	new_ranges         r4   _shallow_copyzRangeIndex._shallow_copy  s    !Z/tzzT<<#d"**== %V,|!l1o&:?DfQid):DAI:)))$)??$$00d0CCr6   c                    t        |       j                  | j                  | j                        }| j                  |_        |S )Nr8   )rk   r>   r+   rQ   rR   )r3   rV   s     r4   _viewzRangeIndex._view  s3    d''$**'Er6   c                V    | j                  ||      d   }| j                  |      }|S )N)r9   r   r   r8   )_validate_names_rename)r3   r9   r   	new_indexs       r4   r=   zRangeIndex.copy  s2    ##D#9!<LLdL+	r6   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:   rt   minr   ry   )rw   r_   nanrF   rD   )r3   methno_stepss      r4   _minmaxzRangeIndex._minmax  sc    t9q=r>66Mem		A45=TYYQR]::zzDII000r6   c                z    t        j                  |       t        j                  ||       | j                  d      S )z#The minimum value of the RangeIndexr   )nvvalidate_minmax_axisvalidate_minr   r3   axisskipnaargskwargss        r4   r   zRangeIndex.min  -    
%
f%||E""r6   c                z    t        j                  |       t        j                  ||       | j                  d      S )z#The maximum value of the RangeIndexry   )r   r   validate_maxr   r   s        r4   ry   zRangeIndex.max  r   r6   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   r^   r:   rt   )	popr   validate_argsortr+   rF   r_   r`   rw   intp)r3   r   r   r   rV   s        r4   argsortzRangeIndex.argsort  s     JJ{D1	

64 
D&);;aYYs4y8FYYs4y1}b"BGGDFDbD\Fr6   c                    t        j                  t        |       t         j                        }| }|r| j                  dk  r|d d d   }|d d d   }||fS )Nr^   r   rt   )r_   r`   rw   r   rF   )r3   sortuse_na_sentinelcodesuniquess        r4   	factorizezRangeIndex.factorize  sR    
 		#d)2773DIIM$B$KEddmGg~r6   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)r3   otherr   s     r4   r   zRangeIndex.equals)  s1     eZ(;;%,,..w~e$$r6   .return_indexerr   na_positionr   c                    y r/   r   r3   r   r   r   r   s        r4   sort_valueszRangeIndex.sort_values2       	r6   )r   r   r   c                    y r/   r   r   s        r4   r   zRangeIndex.sort_values=  r   r6   c                    y r/   r   r   s        r4   r   zRangeIndex.sort_valuesH  r   r6   z3.0r3   r   )versionallowed_argsr9   c                "   |t         |   ||||      S | }d}|r| j                  dk  r$| d d d   }d}n| j                  dkD  r
| d d d   }d}|r=|rt        t	        |       dz
  dd      }nt        t	        |             }|t        |      fS |S )Nr   Fr   rt   Tr:   )r   r   rF   r*   rw   r(   )	r3   r   r   r   r   sorted_indexinverse_indexerrH   r   s	           r4   r   zRangeIndex.sort_valuesS  s     ?7&-#'	 '    L#O99q=#'":L&*O99q=#'":L&*OCIM2r2CI&C00r6   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   rt   )r<   r(   r   _intersectionrF   r+   ry   rD   r   rE   r>   _empty_range_extended_gcdr*   _min_fitting_elementr   )r3   r   r   firstsecondint_lowint_highgcds_	tmp_startnew_stepr   r   	new_startr   s                  r4   r   zRangeIndex._intersection|  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r6   c                    || j                   z
   t        | j                        z   }| j                   t        | j                        |z  z   S )z?Returns the smallest element greater than or equal to the limit)rD   absrF   )r3   lower_limitr   s      r4   r  zRangeIndex._min_fitting_element  s?    "TZZ/0C		NBCzzC		NX555r6   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   r   )
r3   abr  old_stold_trold_rquotients
             r4   r  zRangeIndex._extended_gcd  su     55a5zH%(Q,.1E%(Q,.1E%(Q,.1E	 
 eU""r6   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:   rt   )r+   rw   rF   rD   )r3   r   s     r4   _range_in_selfzRangeIndex._range_in_self  s\     {{u:>ejj4;;+;+;;{{dkk)FeBi4;;.FFr6   c                   t        |t              rO|dv s1|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 : bool or None, default None
            Whether to sort (monotonically increasing) the resulting index.
            ``sort=None|True`` returns a ``RangeIndex`` if possible or a sorted
            ``Index`` with a int64 dtype if not.
            ``sort=False`` can return a ``RangeIndex`` if self is monotonically
            increasing and other is fully contained in self. Otherwise, returns
            an unsorted ``Index`` with an int64 dtype.

        Returns
        -------
        union : Index
        NTFr   r:      r   )r<   r(   rF   r  r+   rD   rw   r  r   ry   rk   r   _union)r3   r   r   start_sstep_send_sstart_ostep_oend_ostart_rend_rr   s              r4   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$~//r6   c                   | j                  |       | j                  |       | j                  |      \  }}t        |t              st
        
|   ||      S |dur&| 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   Fr   rt   r8   r:      r  )_validate_sort_keyword_assert_can_do_setop_convert_can_do_setopr<   r(   r   _differencerF   r   get_op_result_namer+   intersectionrw   renamerD   r*   rE   rk   r>   )r3   r   r   result_nameres_namer  overlapnew_rngrF   r   r   s             r4   r-  zRangeIndex._difference  s   ##D)!!%(!77>{%,7&u4&88uQ":))%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r6   c                    t        |t              r|t        |   |||      S | j	                  |      }|j	                  |       }|j                  |      }||j                  |      }|S r/   )r<   r(   r   symmetric_difference
differenceunionr0  )r3   r   r1  r   leftrightrV   r   s          r4   r6  zRangeIndex.symmetric_differencem  sm     %,0@7/{DIIu%  &E""]];/Fr6   c                   t        |      rF|dt        |        fv r| dd  S |dt        |       dz
  fv r| d d S t        |       dk(  r|dv 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:   rt   r(  )r:   r)  r  r^   Fr   )r   rw   r   is_list_likemaybe_indices_to_slicer_   r   r   r<   slicer7  r   delete)r3   locslcr   r   s       r4   r?  zRangeIndex.delete  s     c?q3t9*o%ABxr3t9q=))CRy 4yA~#.CaCy c",,RZZ277-KSQUYWC#u% S	u599w~c""r6   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   r8   rt   r  )rw   r   r   r+   rF   r*   rD   rE   rk   r>   rQ   r   r   insert)r3   r@  itemrH   r4  rF   r   s         r4   rC  zRangeIndex.insert  sY   t9*T*htn ++CaxDDGdii$77		CHH 4chhIDz--gDJJ-GGD	!dd2h.B&B		388chh+>IDz--gDJJ-GGTaDDGdii!m,C$C499q=)

DIIt<Dz--gDJJ-GGw~c4((r6   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 ]>  }|j                  }	|)|	j                  }|t        |	      dkD  r~|	j                  }nq|o|	j                  |k(  rQt        j                  |D 
cg c]  }
|
j                   c}
      }| j                  |      }|j                  |      c S |	j                  |z
  }||	j                  k7  xr t        |	      dkD  xs |duxr |	j                  |k7  }|rO| j                  t        j                  |D 
cg c]  }
|
j                   c}
            }|j                  |      c S |7|	d   |z   }A |r/||d   j                  n|}t        |||      j                  |      S t        dd      j                  |      S c c}w c c}
w c c}
w )a  
        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, Index with a int64 dtype otherwise. E.g.:
        indexes = [RangeIndex(3), RangeIndex(3, 6)] -> RangeIndex(6)
        indexes = [RangeIndex(3), RangeIndex(4, 6)] -> Index([0,1,2,4,5], dtype='int64')
        c              3  <   K   | ]  }t        |t                y wr/   )r<   r(   r   r   s     r4   r   z%RangeIndex._concat.<locals>.<genexpr>  s     >:a,>s   r:   r   Nrt   )allr   _concatrw   r   r   r(   r+   rD   rF   r_   concatenater-   r\   r0  rE   )r3   indexesr9   rng_indexesrD   rF   next_objnon_empty_indexesrH   r   rU   rV   non_consecutiverE   r   s                  r4   rI  zRangeIndex._concat  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!..v6F!==..yy5(#sxx/@CHqL T!8cii5&8  **NN{#C!AII#CD }}T**B$7	':  27$R(--EDeT4077== !Q&&t,,O E -M $Ds   G?)G?H
3H	c                ,    t        | j                        S )z5
        return the length of the RangeIndex
        )rw   r+   r2   s    r4   __len__zRangeIndex.__len__  s     4;;r6   c                    t        |       S r/   )rw   r2   s    r4   sizezRangeIndex.size  s    4yr6   c           	     4   t        |t              r| 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.
        index ' 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>  _getitem_slicer   r   r+   
IndexErrorrw   r   r   __getitem__)r3   r   r   r   r   s       r4   rZ  zRangeIndex.__getitem__  s     c5!&&s++_#hG{{7++
 s^+  w"3''   SE!HTTs   A. .	B7BBc                l    | j                   |   }t        |       j                  || j                        S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r8   )r+   rk   r>   rQ   )r3   slobjress      r4   rX  zRangeIndex._getitem_slice  s0     kk% Dz%%c

%;;r6   __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:   r8   )	r   rw   rD   rF   r*   r>   rQ   r   r^  )r3   r   rD   rF   rE   r   r   s         r4   r^  zRangeIndex.__floordiv__  s    e!4yA~e!3q!8TYY=NRS=S

e+yyE)s4y4//!%tyq9	''	

'CC4yA~

e+!%A6	''	

'CCw#E**r6   c                    d| j                   vS )Nr   r   r3   r   r   s      r4   rH  zRangeIndex.all"  s    ##r6   c                ,    t        | j                        S r/   )anyr+   ra  s      r4   rc  zRangeIndex.any%  s    4;;r6   c                    t        |t              r)| j                  |j                  k(  rt        |   | |      S t        |   ||      S r/   )r<   r(   r+   r   _cmp_method)r3   r   opr   s      r4   re  zRangeIndex._cmp_method*  s@    eZ(T[[ELL-H7&tR00w"5"--r6   c           	     :   t        |t              rt        S t        |t        t        j
                  f      rt        |   ||      S t        j                  t        |dd      d      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        j0                  fv r|}t3        |dd      }| }	 |rEt	        j4                  d      5   ||j6                  |      }ddd       t9              r|s2t:        |t        j<                  k(  r|j6                   n|j6                  }t	        j4                  d      5   ||j>                  |      } ||j@                  |      }ddd       t        jB                  | |      }	 tE        |       ||	      }
tG        d	 |||fD              s|
jI                  d
      }
|
S # 1 sw Y   xY w# 1 sw Y   hxY w# t:        tJ        tL        f$ r t        |   ||      cY S w xY w)z
        Parameters
        ----------
        other : Any
        op : callable that accepts 2 params
            perform the binary op
        rG   NmT)extract_numpyextract_rangeignore)rH  r8   c              3  2   K   | ]  }t        |        y wr/   )r   rG  s     r4   r   z+RangeIndex._arith_method.<locals>.<genexpr>q  s     Ez!}Es   r   )'r<   r   NotImplementedr   r_   timedelta64r   _arith_methodr   is_np_dtyper   operatorpowr   rpowmodrmodfloordiv	rfloordivdivmodrdivmodmulrmultruedivrtruedivr   errstaterF   r   rB   rsubrD   rE   r.  rk   rH  astyperA   ZeroDivisionError)r3   r   rf  rF   r:  r9  rsteprstartrstopr2  rV   r   s              r4   ro  zRangeIndex._arith_method0  s&    e./!!	2>>:; 7(33__WUGT:C@7(33LLHHLLHHMMKK	
 	
 7(33 $(,,(*:*:CLLIID e4tL 	4[[X. 3 E2E3
 "%($$ ')CHHn
$))* -DJJ.499e,- --dE:HT$Zu8DF
 Evue.DEEy1M33 3- - I'89 	47(33	4sD   I3 (I<AI3 'I' AI3 I$ I3 'I0,I3 3$JJc                   |rt        j                  d|       t        |      rt        d      t	        |      }| j                  |||       t        |      dk(  r"t        j                  g | j                        }n|j                         }|t        |       k\  rt        d| dt        |              |j                         }|t        |        k  rt        d| dt        |              |j                  | j                  d      }|dk  r|t        |       z  }| j                  d	k7  r|| j                  z  }| j                  dk7  r|| j                  z  }| j                   j#                  || j$                  
      S )Nr   z!Expected indices to be array-liker   r^   rV  rW  safe)castingr:   r8   )r   validate_taker   rA   r   _maybe_disallow_fillrw   r_   arrayrG   ry   rY  r   r  rF   rD   r\   r>   r9   )	r3   indicesr   
allow_fill
fill_valuer   takenind_maxind_mins	            r4   takezRangeIndex.take|  sb    R(W?@@%g. 	!!*j'Bw<1HHRtzz2EkkmG#d)# WI%LSQUYKX  kkmG#d)# WI%LSQUYKX  NN4::vN>E{T"yyA~"zzQ#   ,,U,CCr6   )returnztype[libindex.Int64Engine])NNNNFN)rG   Dtype | Noner=   boolr9   Hashable | Noner  r%   )NN)rM   r*   rG   r  r  r%   r/   )rU   r*   r9   r  r  r%   )rG   r  r  None)r  ztype[Index])r  r,   )r  zlist[tuple[str, int]])rz   	list[str]r{   rx   r  r  )r  r   )F)r   r  r  r   )r  znp.dtype)r  r  )r   r	   r  r  )r  rx   )NNN)r   r   r   z
str | Noner   z
int | Noner  npt.NDArray[np.intp])r  z	list[int])r  zIterator[int])r9   r   )r  r%   r   )r9   r  r   r  r  r%   )r   rx   r  )r   r  r  r   )r  r  )FT)r   r  r   r  r  z'tuple[npt.NDArray[np.intp], RangeIndex])r   rP   r  r  )
r   zLiteral[False]r   r  r   r$   r   Callable | Noner  r%   )
r   zLiteral[True]r   r  r   r$   r   r  r  z$tuple[Self, np.ndarray | RangeIndex])
r   r  r   r  r   r$   r   r  r  z+Self | tuple[Self, np.ndarray | RangeIndex])FTlastN)r   r   r   r  )r  r   r  r   )r  r   r  r   r  ztuple[int, int, int])r   r*   r  r  )r   r   r   zbool | None)r1  r  )r  r   )r@  r   r  r   )rK  zlist[Index]r9   r   r  r   )r\  r>  r  r%   )r   TN)r   r"   r  r  r  r   )KrK   
__module____qualname____doc___typr   rX   __annotations__propertyr5   rI   classmethodrN   r>   r;   r   r\   rb   re   rm   rr   r   rD   rE   rF   r   r   rG   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r=   r   r   ry   r   r   r   r   r   r   r   r  r  r  r  r-  r6  r?  rC  rI  rR  rT  rZ  rX  r!   r^  rH  rc  re  ro  r  __classcell__)r   s   @r4   r(   r(   B   s   8t D"9;K!LM$ $ " $"/
 "/ "/ "/ 
"/H 0 06 48"1	     
 K KN
7D ! !"         0 
 
2     6 6 6 6"   	
 
 " )) ) 	) 
)<  ! 	  			5? D D
 	_ 
1##8  $

 
 
1	
%  *-"%" ' 	
    
  
 "%" & 	
    
.    #"%"  	
    
5  $VH=
  %"(#! !  !   	! 
 !  
5! ! L,\6
#"	GI0VUp @D"1$#,)*;-z   (.< n-+ .+$$ 
.H4^ 'D 'D 	'D 
'Dr6   r(   )G
__future__r   collections.abcr   r   datetimer   rq  sysr   typingr   r	   r
   r   r   r   numpyr_   pandas._libsr   r0   r   pandas._libs.algosr   pandas._libs.libr   pandas.compat.numpyr   r   pandas.util._decoratorsr   r   r   pandas.core.dtypes.commonr   r   r   r   r   r   pandas.core.dtypes.genericr   pandas.corer   pandas.core.commoncorecommonr?   pandas.core.constructionr   pandas.core.indexes.baserK  baseri   r   r    pandas.core.ops.commonr!   pandas._typingr"   r#   r$   r%   r&   r*   r   rG   ra   r   r(   r   r6   r4   <module>r     s    "      - ' .   9      2 ( ( <  Qxrxx!aD aDr6   