
    EgW                       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jC        ejD                  ZE G d de7          ZFdS )    )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dd
            Z		 	 	 	 	 	 dddZ
eddd            Ze	 ddd            Zedd            Zedd            Zedd            ZddZd  Zd! Zdd&Zedd(            Zedd)            Zedd*            Zedd+            Zddd-Zedd/            Zedd0            Zedd1            Zedd2            Zdd5Zedd6            Z  e!e"j#                  dd7            Z#	 	 	 dd fd?Z$edd@            Z%ddBZ& e!e"j'                  ddD            Z' e!e"j(                  e)fddF            Z(ddGZ* e!e"j+                  dddH            Z+ddJZ,dddMZ-dddNZ.ddOZ/	 	 dddSZ0d fdVZ1e2dWdWdWdWdXdd_            Z3e2dWdWdWd`ddc            Z3e2dWdWdWdWdXdde            Z3 e4dfdggdhi          	 	 	 	 dd fdk            Z3dd fdlZ5ddnZ6ddrZ7ddsZ8d fduZ9d fdv	Z:	 dd fdxZ;d fdyZ<d fd{Z=d fd~Z>ddZ?edd            Z@ fdZAddZB eCd           fd            ZDddZEddZF fdZG fdZH	 	 	 ddd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_valuesreturntype[libindex.Int64Engine]c                    t           j        S N)libindexInt64Engineselfs    N/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/indexes/range.py_engine_typezRangeIndex._engine_type   s    ##    NFdtypeDtype | NonecopyboolnameHashable | Noner%   c                .   |                      |           t          |||           }t          ||           r|                    |          S t          |t                    r|                     ||          S t          j        |||          rt          d          |t          |          nd}|d|}}nt          |          }|t          |          nd}|dk    rt          d          t	          |||          }|                     ||          S )Nr=   z,RangeIndex(...) must be called with integersr      zStep must not be zero)_validate_dtyper    
isinstancer;   r*   _simple_newcomall_none	TypeErrorr   
ValueError)clsstartstopstepr9   r;   r=   rngs           r6   __new__zRangeIndex.__new__   s-    	E"""!$s33 eS!! 	5::4:(((u%% 	5??5t?444 <tT** 	LJKKK,1,=!%(((1<U4EE$T**D*.*: &&&1994555E4&&s...r8   datac                    t          |t                    s't          | j         dt	          |           d          |                     |           |                     ||          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 passedr@   )rC   r*   rG   __name__reprrB   rD   )rI   rO   r=   r9   s       r6   
from_rangezRangeIndex.from_range   s{    " $&& 	< 2 2t**2 2 2   	E"""t$///r8   valuesc                    t                               |           }t          |t                    sJ ||_        ||_        i |_        |                                 d |_        |S r1   )	objectrN   rC   r*   r+   _name_cache_reset_identity_references)rI   rT   r=   results       r6   rD   zRangeIndex._simple_new   s_     $$&%(((((   !r8   Nonec                b    |d S | j         \  }} ||          st          d| d|           d S )Nz#Incorrect `dtype` passed: expected z, received )_dtype_validation_metadatarH   )rI   r9   validation_funcexpecteds       r6   rB   zRangeIndex._validate_dtype   sZ    =F$'$B!u%% 	RhRR5RR  	 	r8   type[Index]c                    t           S )z(return the class to use for construction)r   r4   s    r6   _constructorzRangeIndex._constructor   s	     r8   c                d    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``.
        r9   )nparangerJ   rK   rL   int64r4   s    r6   _datazRangeIndex._data   s%     yTY	JJJJr8   list[tuple[str, int]]c                D    | j         }d|j        fd|j        fd|j        fgS )z,return a list of tuples of start, stop, steprJ   rK   rL   )r+   rJ   rK   rL   r5   rM   s     r6   _get_data_as_itemszRangeIndex._get_data_as_items   s+    k#)$vsx&8638:LMMr8   c                    d| j         i}|                    t          |                                                      t          j        t          |           |fd fS )Nr=   )rW   updatedictrm   ibase
_new_Indextype)r5   ds     r6   
__reduce__zRangeIndex.__reduce__   sN    TZ 	d--//00111$t**a$66r8   c                    t          d|                                           }| j        .|                    dt	          j        | j                  f           |S )zH
        Return a list of tuples of the (attr, formatted_value)
        zlist[tuple[str, str | int]]Nr=   )r   rm   rW   appendrq   default_pprint)r5   attrss     r6   _format_attrszRangeIndex._format_attrs  sQ     2D4K4K4M4MNN:!LL&%"6tz"B"BCDDDr8   header	list[str]na_repstrc                  t          | j                  s|S t          | j        d                   }t          | j        d                   }t          t          |          t          |                    |fd| j        D             z   S )Nr   c                    g | ]	}|d  
S )< ).0x
max_lengths     r6   
<listcomp>z2RangeIndex._format_with_header.<locals>.<listcomp>  s'    CCC!A-
---CCCr8   )lenr+   r~   max)r5   r{   r}   first_val_strlast_val_strr   s        @r6   _format_with_headerzRangeIndex._format_with_header  s    4; 	MDKN++4;r?++]++S->->??
CCCCt{CCCCCr8   intc                    | 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+   rJ   r4   s    r6   rJ   zRangeIndex.start  s      {  r8   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+   rK   r4   s    r6   rK   zRangeIndex.stop*  s     {r8   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+   rL   r4   s    r6   rL   zRangeIndex.step;  s    . {r8   c                h    | j         t                    t          fddD                       z   S )zD
        Return the number of bytes in the underlying data.
        c              3  R   K   | ]!}t          t          |                    V  "d S r1   )r   getattr)r   	attr_namerM   s     r6   	<genexpr>z$RangeIndex.nbytes.<locals>.<genexpr>Z  sI       $
 $
 gc9--..$
 $
 $
 $
 $
 $
r8   )rJ   rK   rL   )r+   r   sumrl   s    @r6   nbyteszRangeIndex.nbytesT  sQ    
 k~~ $
 $
 $
 $
6$
 $
 $
 !
 !
 
 	
r8   deepc                    | 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   )r5   r   s     r6   memory_usagezRangeIndex.memory_usage_  s    . {r8   np.dtypec                    t           S r1   )_dtype_int64r4   s    r6   r9   zRangeIndex.dtypex  s    r8   c                    dS )z%return if the index has unique valuesTr   r4   s    r6   	is_uniquezRangeIndex.is_unique|  s	     tr8   c                H    | j         j        dk    pt          |           dk    S Nr   rA   r+   rL   r   r4   s    r6   is_monotonic_increasingz"RangeIndex.is_monotonic_increasing  !    {!#5s4yyA~5r8   c                H    | j         j        dk     pt          |           dk    S r   r   r4   s    r6   is_monotonic_decreasingz"RangeIndex.is_monotonic_decreasing  r   r8   keyr	   c                v    t          |           	 t          |          }n# t          $ r Y dS w xY w|| j        v S NF)hashr   rG   r+   )r5   r   s     r6   __contains__zRangeIndex.__contains__  sP    S				#C((CC 	 	 	55	dk!!s   ! 
//c                    dS )Nintegerr   r4   s    r6   inferred_typezRangeIndex.inferred_type  s    yr8   c                   t          |          s#t          |          r`|                                 rLt          |          }	 | j                            |          S # t
          $ r}t          |          |d }~ww xY wt          |t                    rt          |          | 	                    |           t          |          r1   )
r   r   r   r+   r   rH   KeyErrorrC   r   _check_indexing_error)r5   r   new_keyerrs       r6   get_loczRangeIndex.get_loc  s    c?? 	-x}} 	-1A1A 	-#hhG-{((111 - - -smm,-c8$$ 	 3--""3'''smms   A 
A<'A77A<targetr   method
str | Nonelimit
int | Nonenpt.NDArray[np.intp]c                   t          j        |||          r%t                                          ||||          S | j        dk    r| j        | j        | j        }}}n%| j        d d d         }|j        |j        |j        }}}t          j	        |          }	|	|z
  }
|
|z  dk    |
dk    z  |	|k     z  }d|
| <   |
|         |z  |
|<   || j        k    rt          |           dz
  |
|         z
  |
|<   t          |
          S )N)r   	tolerancer   r   r   rA   )rE   any_not_nonesuper_get_indexerrL   rJ   rK   r+   rf   asarrayr   r   )r5   r   r   r   r   rJ   rK   rL   reversetarget_arraylocsvalid	__class__s               r6   r   zRangeIndex._get_indexer  s    FIu55 	77''v% (    9q== $
DIty4EE k$$B$'G 'w|W\4Ez&))e#!dai0L44GHeV5kD(U49d))a-$u+5DK"4(((r8   c                    dS )zA
        Should an integer key be treated as positional?
        Fr   r4   s    r6   _should_fallback_to_positionalz)RangeIndex._should_fallback_to_positional  s	    
 ur8   	list[int]c                *    t          | j                  S r1   )listr+   r4   s    r6   tolistzRangeIndex.tolist  s    DK   r8   Iterator[int]c              #  $   K   | j         E d {V  d S r1   r+   r4   s    r6   __iter__zRangeIndex.__iter__  s&      ;r8   r   c                   |t           u r| j        n|}|j        j        dk    rt	          ||t
          j                  S t          |          }t          |          dk    rX|d         dk    rL|d         }t          |d         |d         |z   |          }t          |                               ||          S | j                            ||          S )Nf)r=   r9   rA   r   r   r@   )r   rW   r9   kindr   rf   float64r   r   r*   rs   rD   rc   )r5   rT   r=   unique_diffsdiff	new_ranges         r6   _shallow_copyzRangeIndex._shallow_copy  s    !Z//tzzT<##d"*==== %V,,|!!l1o&:&:?DfQid):DAAI::)))$)???$00d0CCCr8   c                z    t          |                               | j        | j                  }| j        |_        |S )Nr@   )rs   rD   r+   rW   rX   )r5   r[   s     r6   _viewzRangeIndex._view  s2    d''$*'EEr8   c                l    |                      ||          d         }|                     |          }|S )N)r=   r   r   r@   )_validate_names_rename)r5   r=   r   	new_indexs       r6   r;   zRangeIndex.copy  s8    ##D#99!<LLdL++	r8   methc                    t          |           dz
  }|dk    rt          j        S |dk    r| j        dk    s|dk    r| j        dk     r| j        S | j        | j        |z  z   S )NrA   r   minr   r   )r   rf   nanrL   rJ   )r5   r   no_stepss      r6   _minmaxzRangeIndex._minmax  sc    t99q=r>>6Memm	A45==TYQR]]:zDI000r8   Tskipnac                ~    t          j        |           t          j        ||           |                     d          S )z#The minimum value of the RangeIndexr   )nvvalidate_minmax_axisvalidate_minr   r5   axisr   argskwargss        r6   r   zRangeIndex.min  7    
%%%
f%%%||E"""r8   c                ~    t          j        |           t          j        ||           |                     d          S )z#The maximum value of the RangeIndexr   )r   r   validate_maxr   r   s        r6   r   zRangeIndex.max  r   r8   c                   |                     dd          }|                     dd           t          j        ||           | j        j        dk    r.t          j        t          |           t
          j                  }n2t          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   re   rA   r   )	popr   validate_argsortr+   rL   rf   rg   r   intp)r5   r   r   r   r[   s        r6   argsortzRangeIndex.argsort  s     JJ{D11	

64   
D&)));aYs4yy888FFYs4yy1}b"BGDDDF 	"DDbD\Fr8   sortuse_na_sentinel'tuple[npt.NDArray[np.intp], RangeIndex]c                    t          j        t          |           t           j                  }| }|r!| j        dk     r|d d d         }|d d d         }||fS )Nre   r   r   )rf   rg   r   r   rL   )r5   r   r   codesuniquess        r6   	factorizezRangeIndex.factorize  s_    
 	#d))27333 	$DIMM$$B$KEdddmGg~r8   otherrV   c                    t          |t                    r| j        |j        k    S t                                          |          S )zL
        Determines if two Index objects contain the same elements.
        )rC   r(   r+   r   equals)r5   r   r   s     r6   r   zRangeIndex.equals)  s<     eZ(( 	/;%,..ww~~e$$$r8   .return_indexerr   na_positionr   r  Literal[False]r   r  r$   Callable | Nonec                   d S r1   r   r5   r  r   r  r   s        r6   sort_valueszRangeIndex.sort_values2  	     	r8   )r   r  r   Literal[True]$tuple[Self, np.ndarray | RangeIndex]c                   d S r1   r   r  s        r6   r  zRangeIndex.sort_values=  r  r8   +Self | tuple[Self, np.ndarray | RangeIndex]c                   d S r1   r   r  s        r6   r  zRangeIndex.sort_valuesH  r  r8   z3.0r5   r  )versionallowed_argsr=   lastc                j   |%t                                          ||||          S | }d}|r| j        dk     r| d d d         }d}n| j        dk    r| d d d         }d}|rQ|r"t          t	          |           dz
  dd          }nt          t	          |                     }|t          |          fS |S )Nr   Fr   r   TrA   )r   r  rL   r*   r   r(   )	r5   r  r   r  r   sorted_indexinverse_indexerrM   r   s	           r6   r  zRangeIndex.sort_valuesS  s     ?77&&-#'	 '     L#O +9q==#'":L&*O9q==#'":L&*O 	  'CIIM2r22CII&&C00r8   c                   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| 
                    t                    S |                     |j        |j                  \  }}}	|j        |j        z
  |z  r| 
                    t                    S |j        |j        |j        z
  |j        z  |z  |z  z   }
|j        |j        z  |z  }t          |
||          }| 
                    |          }|                    |          }t          ||j	        |j                  }| 
                    |          }| j        dk     o
|j        dk     |j        dk     ur|d d d         }||                                }|S )Nr   r   r   )rC   r(   r   _intersectionrL   r+   r   rJ   r   rK   rD   _empty_range_extended_gcdr*   _min_fitting_elementr  )r5   r   r   firstsecondint_lowint_highgcds_	tmp_startnew_stepr   r   	new_startr   s                  r6   r  zRangeIndex._intersection|  s    %,, 	;77((T(:::%)Y]]DDbD!!',zA~~ddd##5< ek6<00uz6;//w##L111 &&uz6;??	Q K&,&#- 	2##L111 K6<%+#="Ks"RUV"VV	:+s2)Xx88	$$Y//	 227;;	)Y^Y^DD	$$Y//	IM,ej1ninq6HII!$$B$I<!--//Ir8   lower_limitc                    || j         z
   t          | j                  z   }| j         t          | j                  |z  z   S )z?Returns the smallest element greater than or equal to the limit)rJ   absrL   )r5   r$  r   s      r6   r  zRangeIndex._min_fitting_element  s;    "TZ/0C	NNBCzC	NNX555r8   abtuple[int, int, int]c                v    d\  }}d\  }}||}}|r%||z  }	|||	|z  z
  }}|||	|z  z
  }}|||	|z  z
  }}|%|||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   rA   )rA   r   r   )
r5   r'  r(  r  old_stold_trold_rquotients
             r6   r  zRangeIndex._extended_gcd  s     55a5 	/zH%(Q,.1E%(Q,.1E%(Q,.1E	  	/
 eU""r8   c                    |sdS | j         sdS t          |          dk    r|j        | j         j        z  rdS |j        | j         v o|d         | j         v S )z)Check if other range is contained in selfTFrA   r   )r+   r   rL   rJ   )r5   r   s     r6   _range_in_selfzRangeIndex._range_in_self  sc      	4{ 	5u::>>ej4;+;;>5{dk)FeBi4;.FFr8   bool | Nonec                P   t          |t                    rm|dv s,|du rd| j        dk    rX|                     |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    r2t          |          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    rUt          ||z
            |dz  k    r<t          ||z
            |dz  k    r# t          |           |	|
|dz  z   |dz            S n||z  dk    r<||z
  |z  dk    r/||z   |k    r&||z
  |k    r t          |           |	|
|z   |          S nD||z  dk    r;||z
  |z  dk    r/||z   |k    r&||z
  |k    r t          |           |	|
|z   |          S t                                          ||          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   rA      r  )rC   r(   rL   r2  r+   rJ   r   r&  r   r   rs   r   _union)r5   r   r   start_sstep_send_sstart_ostep_oend_ostart_rend_rr   s              r6   r7  zRangeIndex._union  s   ( eZ(( 3	K|##$)a--D4G4G4U4U- #'*di
TY#d))a-%@@"'+uzejCJJN&CC9q==-2VGWUVG:>>-2VGWUVGt99>>c%jjAoo&)$*u{*B&C&CCFVVYY!^^#FFZZ1__#Fgw//E5))V## 7*f499$u_77$u_77)tDzz'56>6JJJ!q 7!233vzAA //6A:==  *tDzz'56A:3EvPQzRRRf_)) 7*f499$v-88"V^u44)tDzz'56>6JJJf_)) 7*f499$v-88"V^u44)tDzz'56>6JJJww~~e$~///r8   c                r   |                      |           |                     |           |                     |          \  }}t          |t                    s#t                                          ||          S |dur)| j        dk     r| d d d                             |          S t          j	        | |          }| j        dk     r| j
        d d d         n| j
        }|                     |          }|j        dk     r|d d d         }t          |          dk    r|                     |          S t          |          t          |           k    r| d d                             |          S t          |          dk    r|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    r+t          |d         |j        z   |j        |j                  }nc|d         |d         k    r#t          |j        |d         |j                  }n.|j
        |dd         k    rt          |          dz
  }|d d |         }nt                                          ||          S t          |           dk    sJ |j        |j        dz  k    r|d         |d         k    r$|d         |d         |d	         fv r|dd d         }n||d         |d         k    r$|d         |d         |d	         fv r|d d d         }nFt                                          ||          S t                                          ||          S t#          |                               ||          }	|| j
        ur|	d d d         }	|	S )
Nr  Fr   r   r@   rA      r6  )_validate_sort_keyword_assert_can_do_setop_convert_can_do_setoprC   r(   r   _differencerL   r   get_op_result_namer+   intersectionr   renamerJ   r*   rK   rs   rD   )r5   r   r   result_nameres_namer  overlapnew_rngrL   r   r   s             r6   rF  zRangeIndex._difference  s0   ##D)))!!%(((!77>>{%,, 	977&&u4&888uQ":))%000)$66%)Y]]DDbD!!##E**<!dddmGw<<1;;H;---w<<3t99$$8??8,,, w<<1qzT!W$$ABBxtBx''CRCy TaGAJ$q'$9$9CCaCy  ww**5t*<<<\\Q71:q#9#9gbkUSUY>V>V":<5:%%qzU[((ej 8%*ejQQb	))WQZDD52;..5zzA~$- ww**5t*<<<
 t99q====|uzA~--1:q))gbkeBir=S.S.S#ADqDkGGQZ58++b	5QS9?U0U0U#CCaCjGG !77..u4.@@@ ww**5t*<<<JJ**7*BB	##!$$B$Ir8   rJ  c                (   t          |t                    r|#t                                          |||          S |                     |          }|                    |           }|                    |          }||                    |          }|S r1   )rC   r(   r   symmetric_difference
differenceunionrI  )r5   r   rJ  r   leftrightr[   r   s          r6   rO  zRangeIndex.symmetric_differencem  s     %,, 	J0@77//{DIIIu%%  &&E"""]];//Fr8   c                6   t          |          ra|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 nt          j        |          rtt          j        t          j        |t
          j                  t          |                     }t          |t                    r| |         }| 
                    |d	          S t                                          |          S )
Nr   rA   r   rA  )rA   rB  r6  re   Fr  )r   r   r   is_list_likemaybe_indices_to_slicerf   r   r   rC   slicerP  r   delete)r5   locslcr   r   s       r6   rX  zRangeIndex.delete  s    c?? 	:q3t99*o%%ABBxr3t99q=)))CRCy 4yyA~~#..CCaCy c"" 	:,RZ27-K-K-KSQUYYWWC#u%% : S	u5999ww~~c"""r8   rY  c                   t          |           rt          |          st          |          ro| j        }|dk    re|| d         | j        z
  k    rQt          |j        |j        z
  |j        |j                  }t          |           	                    || j
                  S |t          |           k    re|| d         | j        z   k    rQt          |j        |j        |j        z   |j                  }t          |           	                    || j
                  S t          |           dk    rr|| d         | j        dz  z   k    r[t          | j        dz            }t          | j        | j        |          }t          |           	                    || j
                  S t                                          ||          S )Nr   r@   r   r6  )r   r   r   r+   rL   r*   rJ   rK   rs   rD   rW   r   r   insert)r5   rY  itemrM   rM  rL   r   s         r6   r\  zRangeIndex.insert  s   t99 	H*T** 	Hhtnn 	H +CaxxDDGdi$777	CH 4chIIDzz--gDJ-GGGD		!!dd2h.B&B&B	38ch+>IIDzz--gDJ-GGGTaDDGdi!m,C$C$C49q=))
DIt<<Dzz--gDJ-GGGww~~c4(((r8   indexeslist[Index]c                   t          d |D                       s"t                                          ||          S t          |          dk    r|d         S t	          t
          t                   |          }dx}x}}d |D             }|D ]}|j        }	|$|	j        }|t          |	          dk    r|	j	        }na|_|	j        |k    rJt          j        d |D                       }
|                     |
          }|                    |          c S |	j        |z
  }||	j	        k    rt          |	          dk    p|duo
|	j        |k    }|rH|                     t          j        d |D                                 }|                    |          c S ||	d         |z   }|r5||d         j        n|}t          |||                              |          S t          dd                              |          S )	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                    V  d S r1   )rC   r(   r   r   s     r6   r   z%RangeIndex._concat.<locals>.<genexpr>  s,      >>:a,,>>>>>>r8   rA   r   Nc                0    g | ]}t          |          |S r   r   )r   objs     r6   r   z&RangeIndex._concat.<locals>.<listcomp>  s#    DDDS3s88DSDDDr8   c                    g | ]	}|j         
S r   r-   rb  s     r6   r   z&RangeIndex._concat.<locals>.<listcomp>  s    ,L,L,L1QY,L,L,Lr8   c                    g | ]	}|j         
S r   rg  rb  s     r6   r   z&RangeIndex._concat.<locals>.<listcomp>  s    #C#C#C!AI#C#C#Cr8   r   )allr   _concatr   r   r   r(   r+   rJ   rL   rf   concatenaterc   rI  rK   )r5   r^  r=   rng_indexesrJ   rL   next_non_empty_indexesre  rM   rT   r[   non_consecutiverK   r   s                 r6   rj  zRangeIndex._concat  s6    >>g>>>>> 	77??7D111\\Q1:4
+W55###u EDKDDD$ 	' 	'C*C}	<CHHqLL8D9%%^,L,L,L,L,LMMF!..v66F!==.....y5(#sx/@CHHqL T!8ci5&8   +**N#C#C{#C#C#CDD  }}T*****B$ 	> 27$R(--EDeT40077=== !Q&&t,,,r8   c                *    t          | j                  S )z5
        return the length of the RangeIndex
        )r   r+   r4   s    r6   __len__zRangeIndex.__len__  s     4;r8   c                     t          |           S r1   rd  r4   s    r6   sizezRangeIndex.size  s    4yyr8   c           	        t          |t                    r|                     |          S t          |          rRt	          |          }	 | j        |         S # t          $ r(}t          d| dt          |                      |d}~ww xY wt          |          rt          d          t                      
                    |          S )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)rC   rW  _getitem_slicer   r   r+   
IndexErrorr   r   r   __getitem__)r5   r   r   r   r   s       r6   ry  zRangeIndex.__getitem__  s     c5!! 	&&s+++__ 	#hhG{7++    TSTTTTT  s^^ 	+   ww""3'''s   A 
B
"#BB
slobjrW  c                n    | j         |         }t          |                               || j                  S )zH
        Fastpath for __getitem__ when we know we have a slice.
        r@   )r+   rs   rD   rW   )r5   rz  ress      r6   rw  zRangeIndex._getitem_slice  s1     k% Dzz%%c
%;;;r8   __floordiv__c                   t          |          r|dk    rt          |           dk    s| j        |z  dk    rf| j        |z  dk    rX| j        |z  }| j        |z  }|t          |           |z  z   }t	          |||pd          }|                     || j                  S t          |           dk    r:| j        |z  }t	          ||dz   d          }|                     || j                  S t                                          |          S )Nr   rA   r@   )	r   r   rJ   rL   r*   rD   rW   r   r}  )r5   r   rJ   rL   rK   r   r   s         r6   r}  zRangeIndex.__floordiv__  s   e 
	D!4yyA~~e!3q!8!8TY=NRS=S=S
e+yE)s4yy4//!%tyq99	''	
'CCC4yyA~~
e+!%A66	''	
'CCCww##E***r8   c                    d| j         vS )Nr   r   r5   r   r   s      r6   ri  zRangeIndex.all"  s    ##r8   c                *    t          | j                  S r1   )anyr+   r  s      r6   r  zRangeIndex.any%  s    4;r8   c                    t          |t                    r2| j        |j        k    r"t                                          | |          S t                                          ||          S r1   )rC   r(   r+   r   _cmp_method)r5   r   opr   s      r6   r  zRangeIndex._cmp_method*  sW    eZ(( 	1T[EL-H-H77&&tR000ww""5"---r8   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          j        fv r|}t3          |dd          }| }	 |rWt	          j        d          5   ||j        |          }ddd           n# 1 swxY w Y   t9          |          r|st:          n|t          j        k    r|j         n|j        }t	          j        d          5   ||j        |          } ||j         |          }ddd           n# 1 swxY w Y   t          j!        | |          }	 tE          |           ||||	          }
tG          d	 |||fD                       s|
$                    d
          }
|
S # 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
        r9   NmT)extract_numpyextract_rangeignore)ri  r@   c              3  4   K   | ]}t          |          V  d S r1   )r   rb  s     r6   r   z+RangeIndex._arith_method.<locals>.<genexpr>q  s(      EEz!}}EEEEEEr8   r   )'rC   r   NotImplementedr   rf   timedelta64r   _arith_methodr   is_np_dtyper   operatorpowr   rpowmodrmodfloordiv	rfloordivdivmodrdivmodmulrmultruedivrtruedivr   errstaterL   r   rH   rsubrJ   rK   rG  rs   ri  astyperG   ZeroDivisionError)r5   r   r  rL   rS  rR  rsteprstartrstoprK  r[   r   s              r6   r  zRangeIndex._arith_method0  s-    e.// 		4!!	2>:;; 	4 77((333_WUGT::C@@ 	477((333LHLHMK	
 	
 	
 77((333 $(,(*:CLIIID e4tLLL 	4 D[X... 3 3 DE22E3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
 "%(( % %$$%
 ')CHnn

$)*** - -DJ..49e,,- - - - - - - - - - - - - - - -dE::HT$ZZu8DDDF
 EEvue.DEEEEE 2y11MI'89 	4 	4 	477((33333	4s\   )J  FJ F""J %F"&AJ 6#H%J %H))J ,H)-A&J 9KKr   r   r"   
allow_fillc                :   |rt          j        d|           t          |          rt          d          t	          |          }|                     |||           t          |          dk    rt          j        g | j	                  }n|
                                }|t          |           k    r"t          d| dt          |                      |                                }|t          |            k     r"t          d| dt          |                      |                    | j	        d          }|dk     r|t          |           z  }| j        d	k    r
|| j        z  }| j        dk    r
|| j        z  }| j                            || j        
          S )Nr   z!Expected indices to be array-liker   re   ru  rv  safe)castingrA   r@   )r   validate_taker   rG   r   _maybe_disallow_fillr   rf   arrayr9   r   rx  r   r  rL   rJ   rc   rD   r=   )	r5   indicesr   r  
fill_valuer   takenind_maxind_mins	            r6   takezRangeIndex.take|  s     	)R(((W 	A?@@@%g.. 	!!*j'BBBw<<1HRtz222EEkkmmG#d))## XWXXSQUYYXX   kkmmG#d))## XWXXSQUYYXX   NN4:vN>>E{{T"yA~~"zQ#  ,,U,CCCr8   )r.   r/   )NNNNFN)r9   r:   r;   r<   r=   r>   r.   r%   )NN)rO   r*   r9   r:   r.   r%   r1   )rT   r*   r=   r>   r.   r%   )r9   r:   r.   r\   )r.   ra   )r.   r,   )r.   rj   )r{   r|   r}   r~   r.   r|   )r.   r   )F)r   r<   r.   r   )r.   r   )r.   r<   )r   r	   r.   r<   )r.   r~   )NNN)r   r   r   r   r   r   r.   r   )r.   r   )r.   r   )r=   r   )r.   r%   r   )r=   r>   r   r<   r.   r%   )r   r~   r5  )r   r<   r.   r   )r.   r   )FT)r   r<   r   r<   r.   r   )r   rV   r.   r<   )
r  r  r   r<   r  r$   r   r  r.   r%   )
r  r	  r   r<   r  r$   r   r  r.   r
  )
r  r<   r   r<   r  r$   r   r  r.   r  )FTr  N)r   r   r   r<   )r$  r   r.   r   )r'  r   r(  r   r.   r)  )r   r*   r.   r<   )r   r   r   r3  )rJ  r>   )r.   r   )rY  r   r.   r   )r^  r_  r=   r   r.   r   )rz  rW  r.   r%   )r   TN)r   r"   r  r<   r.   r   )KrQ   
__module____qualname____doc___typr   r^   __annotations__propertyr7   rN   classmethodrS   rD   rB   r   rc   ri   rm   ru   rz   r   rJ   rK   rL   r   r   r9   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r;   r   r   r   r   r   r   r   r  r   r  r  r  r2  r7  rF  rO  rX  r\  rj  rq  rs  ry  rw  r!   r}  ri  r  r  r  r  __classcell__)r   s   @r6   r(   r(   B   s        8 8t D"9;K!LMMM$ $ $ X$ " $"/ "/ "/ "/ "/H 0 0 0 0 [06 48    [    [    ^
 K K K ^KN N N N
7 7 7  D D D D ! ! ! X!"       X         X 0 
 
 
 ^
    2    X    X 6 6 6 ^6 6 6 6 ^6" " " "    X 	S
 
 
 
 " ) ) ) ) ) ) )<    ^! ! ! ! 	S    	S	5? D D D D D   
 	S__    _
1 1 1 1# # # # ## # # # #   8  $
 
 
 
 
% % % % % %  *-"%"     X 
 "%"     X   #"%"     X $#VH=  
  %"(#!  !  !  !  !  !  ! L, , , , , , ,\6 6 6 6
# # # #"	G 	G 	G 	GI0 I0 I0 I0 I0 I0VU U U U U Up @D      $# # # # # #,) ) ) ) ) )*;- ;- ;- ;- ;- ;-z           X( ( ( ( (.< < < < n--+ + + + .-+$$ $ $ $       
. . . . .H4 H4 H4 H4 H4^ 'D 'D 'D 'D 'D 'D 'D 'D 'Dr8   r(   )G
__future__r   collections.abcr   r   datetimer   r  sysr   typingr   r	   r
   r   r   r   numpyrf   pandas._libsr   r2   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commonrE   pandas.core.constructionr   pandas.core.indexes.baser^  baserq   r   r    pandas.core.ops.commonr!   pandas._typingr"   r#   r$   r%   r&   r*   r  r9   rh   r   r(   r   r8   r6   <module>r     s   " " " " " "                                               - , , , , , ' ' ' ' ' ' . . . . . .                         9 8 8 8 8 8                         2 2 2 2 2 2 ( ( ( ( ( ( ( ( ( ( ( (        < ; ; ; ; ;               uQxxrx!!aD aD aD aD aD aD aD aD aD aDr8   