a
    OfW                     @  s  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.  m/Z0 d dl1m2Z2 d dl3m.  m4  m5Z6 d dl3m7Z7m8Z8 d dl9m:Z: erXd dl;m<Z<m=Z=m>Z>m?Z?m@Z@ eAd ZBeCejDZEG d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                      s  e Zd ZU dZdZedfZded< ded< edd	d
dZ	ddddddddZ
edddddddZedddddddZedddddZedd	d d!Zedd	d"d#Zd$d	d%d&Zd'd( Zd)d* Zd+d,d+d-d.d/Zed0d	d1d2Zed0d	d3d4Zed0d	d5d6Zed0d	d7d8Zddd0d9d:d;Zed<d	d=d>Zedd	d?d@Zedd	dAdBZedd	dCdDZdEddFdGdHZed,d	dIdJZ e!e"j#d0d	dKdLZ#ddMdNdOdPdQ fdRdSZ$edd	dTdUZ%dVd	dWdXZ&e!e"j'dYd	dZd[Z'e!e"j(e)fd\d]d^d_Z(dd	d`daZ*e!e"j+dddddbdcddZ+d,dedfdgZ,ddd0didjdkZ-ddd0didldmZ.dPd	dndoZ/ddddpdqdrdsZ0dtddu fdvdwZ1e2dxdxdxdxdydzdd{d|dd}d~dZ3e2dxdxdxdddd{d|dd}ddZ3e2dxdxdxdxdyddd{d|dd}ddZ3e4ddgdddddd{d|dd} fddZ3ddMdd fddZ5d0d0dddZ6d0d0ddddZ7ddduddZ8dMdd fddZ9d· fdd	Z:ddd fddZ;dMd	 fddZ<d0dMd fddZ=dd\dMd fddZ>d0d	ddZ?ed0d	ddZ@ fddZAdddddZBeCd fddZDdd	ddZEdd	ddZF fddZG fddZHddddMdddZI  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))
    []
    Z
rangeindexzsigned integerrange_rangez
np.ndarray_valuesztype[libindex.Int64Engine])returnc                 C  s   t jS N)libindexZInt64Engineself r/   R/var/www/ai-form-bot/venv/lib/python3.9/site-packages/pandas/core/indexes/range.py_engine_type   s    zRangeIndex._engine_typeNFzDtype | NoneboolzHashable | Noner$   )dtypecopynamer*   c                 C  s   |  | t||| }t|| r,|j|dS t|trD| j||dS t|||rZtd|d urjt	|nd}|d u rd| }}nt	|}|d urt	|nd}|dkrt
dt|||}| j||dS )Nr5   z,RangeIndex(...) must be called with integersr      zStep must not be zero)_validate_dtyper   
isinstancer4   r'   _simple_newcomZall_none	TypeErrorr   
ValueError)clsstartstopstepr3   r4   r5   rngr/   r/   r0   __new__   s"    	


zRangeIndex.__new__)datar3   r*   c                 C  s<   t |ts$t| j dt| d| | | j||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 passedr6   )r9   r'   r<   __name__reprr8   r:   )r>   rD   r5   r3   r/   r/   r0   
from_range   s    

zRangeIndex.from_range)valuesr5   r*   c                 C  s<   t | }t|tsJ ||_||_i |_|  d |_|S r+   )	objectrC   r9   r'   r(   _name_cacheZ_reset_identityZ_references)r>   rH   r5   resultr/   r/   r0   r:      s    
zRangeIndex._simple_newNone)r3   r*   c                 C  s6   |d u rd S | j \}}||s2td| d| d S )Nz#Incorrect `dtype` passed: expected z, received )_dtype_validation_metadatar=   )r>   r3   Zvalidation_funcexpectedr/   r/   r0   r8      s    
zRangeIndex._validate_dtypeztype[Index]c                 C  s   t S )z(return the class to use for construction)r   r-   r/   r/   r0   _constructor   s    zRangeIndex._constructorc                 C  s   t j| j| j| jt jdS )z
        An int array that for performance reasons is created only when needed.

        The constructed array is saved in ``_cache``.
        r3   )nparanger?   r@   rA   int64r-   r/   r/   r0   _data   s    zRangeIndex._datazlist[tuple[str, int]]c                 C  s"   | j }d|jfd|jfd|jfgS )z,return a list of tuples of start, stop, stepr?   r@   rA   )r(   r?   r@   rA   )r.   rB   r/   r/   r0   _get_data_as_items   s    zRangeIndex._get_data_as_itemsc                 C  s0   d| j i}|t|   tjt| |fd fS )Nr5   )rJ   updatedictrV   ibaseZ
_new_Indextype)r.   dr/   r/   r0   
__reduce__   s    
zRangeIndex.__reduce__c                 C  s2   t d|  }| jdur.|dt| jf |S )zH
        Return a list of tuples of the (attr, formatted_value)
        zlist[tuple[str, str | int]]Nr5   )r   rV   rJ   appendrY   Zdefault_pprint)r.   attrsr/   r/   r0   _format_attrs  s    
zRangeIndex._format_attrsz	list[str]str)headerna_repr*   c                  sT   t | js|S t| jd }t| jd }tt |t | | fdd| jD  S )Nr   c                   s   g | ]}|d   qS )<r/   .0x
max_lengthr/   r0   
<listcomp>      z2RangeIndex._format_with_header.<locals>.<listcomp>)lenr(   r`   max)r.   ra   rb   Zfirst_val_strZlast_val_strr/   rh   r0   _format_with_header  s    
zRangeIndex._format_with_headerintc                 C  s   | 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(   r?   r-   r/   r/   r0   r?     s    zRangeIndex.startc                 C  s   | 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(   r@   r-   r/   r/   r0   r@   *  s    zRangeIndex.stopc                 C  s   | 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(   rA   r-   r/   r/   r0   rA   ;  s    zRangeIndex.stepc                   s$   | j  t t fdddD  S )zD
        Return the number of bytes in the underlying data.
        c                 3  s   | ]}t t |V  qd S r+   )r   getattr)rf   	attr_namerB   r/   r0   	<genexpr>Z  s   z$RangeIndex.nbytes.<locals>.<genexpr>)r?   r@   rA   )r(   r   sumr-   r/   rr   r0   nbytesT  s    zRangeIndex.nbytes)deepr*   c                 C  s   | 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
        )ru   )r.   rv   r/   r/   r0   memory_usage_  s    zRangeIndex.memory_usageznp.dtypec                 C  s   t S r+   )_dtype_int64r-   r/   r/   r0   r3   x  s    zRangeIndex.dtypec                 C  s   dS )z%return if the index has unique valuesTr/   r-   r/   r/   r0   	is_unique|  s    zRangeIndex.is_uniquec                 C  s   | j jdkpt| dkS Nr   r7   r(   rA   rl   r-   r/   r/   r0   is_monotonic_increasing  s    z"RangeIndex.is_monotonic_increasingc                 C  s   | j jdk pt| dkS rz   r{   r-   r/   r/   r0   is_monotonic_decreasing  s    z"RangeIndex.is_monotonic_decreasingr   )keyr*   c                 C  s4   t | zt|}W n ty(   Y dS 0 || jv S )NF)hashr   r<   r(   )r.   r~   r/   r/   r0   __contains__  s    zRangeIndex.__contains__c                 C  s   dS )Nintegerr/   r-   r/   r/   r0   inferred_type  s    zRangeIndex.inferred_typec              
   C  s   t |st|r^|  r^t|}z| j|W S  ty\ } zt||W Y d }~n
d }~0 0 t|trpt|| 	| t|d S r+   )
r   r   ro   r(   r   r=   KeyErrorr9   r   Z_check_indexing_errorr.   r~   Znew_keyerrr/   r/   r0   get_loc  s     

zRangeIndex.get_locr   z
str | Nonez
int | Noneznpt.NDArray[np.intp])targetmethodlimitr*   c                   s   t |||r"t j||||dS | jdkrD| j| j| j  }}}n&| jd d d }|j|j|j  }}}t	|}	|	| }
|
| dk|
dk@ |	|k @ }d|
| < |
| | |
|< || jkrt
| d |
|  |
|< t|
S )N)r   	tolerancer   r   rc   r7   )r;   Zany_not_nonesuper_get_indexerrA   r?   r@   r(   rR   asarrayrl   r   )r.   r   r   r   r   r?   r@   rA   reverseZtarget_arrayZlocsZvalid	__class__r/   r0   r     s     



zRangeIndex._get_indexerc                 C  s   dS )zA
        Should an integer key be treated as positional?
        Fr/   r-   r/   r/   r0   _should_fallback_to_positional  s    z)RangeIndex._should_fallback_to_positionalz	list[int]c                 C  s
   t | jS r+   )listr(   r-   r/   r/   r0   tolist  s    zRangeIndex.tolistzIterator[int]c                 c  s   | j E d H  d S r+   r(   r-   r/   r/   r0   __iter__  s    zRangeIndex.__iter__r   r6   c                 C  s   |t u r| jn|}|jjdkr.t||tjdS t|}t|dkr|d dkr|d }t	|d |d | |}t
| j||dS | jj||dS d S )Nf)r5   r3   r7   r   rc   r6   )r   rJ   r3   kindr   rR   float64r   rl   r'   rZ   r:   rP   )r.   rH   r5   Zunique_diffsdiff	new_ranger/   r/   r0   _shallow_copy  s    zRangeIndex._shallow_copyc                 C  s"   t | j| j| jd}| j|_|S )Nr6   )rZ   r:   r(   rJ   rK   )r.   rL   r/   r/   r0   _view  s    zRangeIndex._view)r5   rv   r*   c                 C  s"   | j ||dd }| j|d}|S )N)r5   rv   r   r6   )Z_validate_namesZ_rename)r.   r5   rv   	new_indexr/   r/   r0   r4     s    zRangeIndex.copy)methc                 C  sT   t | d }|dkrtjS |dkr,| jdks>|dkrD| jdk rD| jS | j| j|  S )Nr7   rc   minr   rm   )rl   rR   nanrA   r?   )r.   r   no_stepsr/   r/   r0   _minmax  s    $zRangeIndex._minmaxT)skipnar*   c                 O  s    t | t || | dS )z#The minimum value of the RangeIndexr   )nvvalidate_minmax_axisZvalidate_minr   r.   axisr   argskwargsr/   r/   r0   r     s    
zRangeIndex.minc                 O  s    t | t || | dS )z#The maximum value of the RangeIndexrm   )r   r   Zvalidate_maxr   r   r/   r/   r0   rm     s    
zRangeIndex.maxc                 O  sx   | dd}| dd t|| | jjdkrFtjt| tjd}ntjt| d ddtjd}|st|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   rQ   r7   rc   )	popr   Zvalidate_argsortr(   rA   rR   rS   rl   intp)r.   r   r   r   rL   r/   r/   r0   argsort  s    zRangeIndex.argsortz'tuple[npt.NDArray[np.intp], RangeIndex])sortuse_na_sentinelr*   c                 C  sJ   t jt| t jd}| }|rB| jdk rB|d d d }|d d d }||fS )NrQ   r   rc   )rR   rS   rl   r   rA   )r.   r   r   codesZuniquesr/   r/   r0   	factorize  s    zRangeIndex.factorizerI   )otherr*   c                   s"   t |tr| j|jkS t |S )zL
        Determines if two Index objects contain the same elements.
        )r9   r&   r(   r   equalsr.   r   r   r/   r0   r   )  s    
zRangeIndex.equals.return_indexerr   na_positionr~   zLiteral[False]r#   zCallable | None)r   r   r   r~   r*   c                C  s   d S r+   r/   r.   r   r   r   r~   r/   r/   r0   sort_values2  s    	zRangeIndex.sort_values)r   r   r~   zLiteral[True]z$tuple[Self, np.ndarray | RangeIndex]c                C  s   d S r+   r/   r   r/   r/   r0   r   =  s    	z+Self | tuple[Self, np.ndarray | RangeIndex]c                C  s   d S r+   r/   r   r/   r/   r0   r   H  s    	z3.0r.   r   )versionZallowed_argsr5   lastc                   s   |d urt  j||||dS | }d}|rF| jdk rb| d d d }d}n| jdkrb| d d d }d}|r|rtt| d dd}ntt| }|t|fS |S d S )Nr   Fr   rc   Tr7   )r   r   rA   r'   rl   r&   )r.   r   r   r   r~   Zsorted_indexZinverse_indexerrB   r   r/   r0   r   S  s,    


)r   r   c                   sh  t |tst j||dS | jdk r4| jd d d n| j}|jdk rT|jd d d n|j}t|j|j}t|j	|j	}||kr| 
tS | |j|j\}}}	|j|j | r| 
tS |j|j|j |j | |  }
|j|j | }t|
||}| 
|}||}t||j	|j}| 
|}| jdk o6|jdk |jdk urR|d d d }|d u rd| }|S )Nr   r   rc   )r9   r&   r   _intersectionrA   r(   rm   r?   r   r@   r:   _empty_range_extended_gcdr'   _min_fitting_elementr   )r.   r   r   firstsecondZint_lowZint_highgcds_Z	tmp_startZnew_stepr   r   	new_startr   r/   r0   r   |  s.    
  

 


"
zRangeIndex._intersection)lower_limitr*   c                 C  s,   || j   t| j  }| j t| j|  S )z?Returns the smallest element greater than or equal to the limit)r?   absrA   )r.   r   r   r/   r/   r0   r     s    zRangeIndex._min_fitting_elementztuple[int, int, int])abr*   c           
      C  sh   d\}}d\}}|| }}|r^|| }	|||	|   }}|||	|   }}|||	|   }}q|||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   r7   )r7   r   r/   )
r.   r   r   r   Zold_stZold_trZold_rZquotientr/   r/   r0   r     s    
zRangeIndex._extended_gcdc                 C  sJ   |sdS | j sdS t|dkr0|j| j j r0dS |j| j v oH|d | j v S )z)Check if other range is contained in selfTFr7   rc   )r(   rl   rA   r?   r   r/   r/   r0   _range_in_self  s    zRangeIndex._range_in_selfzbool | Nonec                   sz  t |trj|dv s8|du rj| jdkrj| |jrj| j| j }}| j| jt| d   }|j|j }}|j|jt|d   }| jdk r|| |  }}}|jdk r|| |  }}}t| dkrt|dkrt| j|j  }}n&t| dk r|}nt|dkr|}t||}	t	||}
||kr|| | dkrp|| |krp|| |krpt
| |	|
| |S |d dkrjt|| |d krjt|| |d krjt
| |	|
|d  |d S n|| dkr|| | dkrj|| |krj|| |krjt
| |	|
| |S nP|| dkrj|| | dkrj|| |krj|| |krjt
| |	|
| |S t j||d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   r7      r   )r9   r&   rA   r   r(   r?   rl   r   r   rm   rZ   r   _union)r.   r   r   Zstart_sZstep_sZend_sZstart_oZstep_oZend_oZstart_rZend_rr   r/   r0   r     sp    












zRangeIndex._unionc           
        sD  |  | | | | |\}}t|ts<t j||dS |durb| jdk rb| d d d |S t	| |}| jdk r| j
d d d n| j
}| |}|jdk r|d d d }t|dkr| j|dS t|t| kr| d d |S t|dkrt|d | d kr| dd  S |d | d kr4| d d S t| dkrb|d | d krb| d d d S t j||dS n>t|dkr|d |d kr|d |d kr| dd S |j|jkrV|d |jkrt|d |j |j|j}nh|d |d krt|j|d |j}n@|j
|dd krDt|d }|d d | }nt j||dS nt| dkshJ |j|jd kr|d |d kr|d |d |d	 fv r|dd d }nL|d |d kr|d |d |d	 fv r|d d d }nt j||dS nt j||dS t| j||d}	|| j
ur@|	d d d }	|	S )
Nr   Fr   rc   r6   r7      r   )Z_validate_sort_keywordZ_assert_can_do_setopZ_convert_can_do_setopr9   r&   r   _differencerA   r   get_op_result_namer(   intersectionrl   renamer?   r'   r@   rZ   r:   )
r.   r   r   result_nameres_namer   Zoverlapnew_rngrA   r   r   r/   r0   r     s^    


 

 2,,zRangeIndex._difference)r   c                   sV   t |tr|d ur"t |||S | |}|| }||}|d urR||}|S r+   )r9   r&   r   symmetric_difference
differenceunionr   )r.   r   r   r   leftrightrL   r   r/   r0   r   m  s    



zRangeIndex.symmetric_differencec                   s   t |rj|dt|  fv r&| dd  S |dt| d fv rF| d d S t| dkr|dv r| d d d S nFt|rttj|tjdt| }t|t	r| | }| j
|dd	S t |S )
Nr   r7   rc   r   )r7   r   r   rQ   Fr   )r   rl   r   Zis_list_likeZmaybe_indices_to_slicerR   r   r   r9   slicer   r   delete)r.   locZslcr   r   r/   r0   r     s    

zRangeIndex.delete)r   r*   c                   s  t | r
t|st|r
| j}|dkrh|| d | j krht|j|j |j|j}t| j	|| j
dS |t | kr|| d | j krt|j|j|j |j}t| j	|| j
dS t | dkr
|| d | jd  kr
t| jd }t| j| j|}t| j	|| j
dS t ||S )Nr   r6   rc   r   )rl   r   r   r(   rA   r'   r?   r@   rZ   r:   rJ   ro   r   insert)r.   r   itemrB   r   rA   r   r/   r0   r     s    &zRangeIndex.insertzlist[Index])indexesr5   r*   c                   s  t dd |D s t ||S t|dkr4|d S ttt |}d } }}dd |D }|D ]}|j}	|du r|	j}|du rt|	dkr|	j	}nH|du r|	j|krt
dd |D }
| |
}||  S |	j| }||	j	krt|	dkp|duo|	j|k}|r6| t
d	d |D }||  S |dur`|	d
 | }q`|r||du rf|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                 s  s   | ]}t |tV  qd S r+   )r9   r&   re   r/   r/   r0   rs     rk   z%RangeIndex._concat.<locals>.<genexpr>r7   r   Nc                 S  s   g | ]}t |r|qS r/   rl   )rf   objr/   r/   r0   rj     rk   z&RangeIndex._concat.<locals>.<listcomp>c                 S  s   g | ]
}|j qS r/   r)   re   r/   r/   r0   rj     rk   c                 S  s   g | ]
}|j qS r/   r   re   r/   r/   r0   rj     rk   rc   )allr   _concatrl   r   r   r&   r(   r?   rA   rR   ZconcatenaterP   r   r@   )r.   r   r5   Zrng_indexesr?   rA   Znext_Znon_empty_indexesr   rB   rH   rL   Znon_consecutiver@   r   r/   r0   r     sB    	


zRangeIndex._concatc                 C  s
   t | jS )z5
        return the length of the RangeIndex
        )rl   r(   r-   r/   r/   r0   __len__  s    zRangeIndex.__len__c                 C  s   t | S r+   r   r-   r/   r/   r0   size  s    zRangeIndex.sizec              
     s   t |tr| |S t|rrt|}z| j| W S  tyn } z&td| dt|  |W Y d}~qd}~0 0 nt|rt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)r9   r   _getitem_slicer   ro   r(   
IndexErrorrl   r   r   __getitem__r   r   r/   r0   r     s"    

zRangeIndex.__getitem__r   )slobjr*   c                 C  s   | j | }t| j|| jdS )zH
        Fastpath for __getitem__ when we know we have a slice.
        r6   )r(   rZ   r:   rJ   )r.   r   resr/   r/   r0   r     s    
zRangeIndex._getitem_slice__floordiv__c                   s   t |r|dkrt| dks8| j| dkr|| j| dkr|| j| }| j| }|t| |  }t|||phd}| j|| jdS t| dkr| j| }t||d d}| j|| jdS t |S )Nr   r7   r6   )	r   rl   r?   rA   r'   r:   rJ   r   r   )r.   r   r?   rA   r@   r   r   r/   r0   r     s    (


zRangeIndex.__floordiv__c                 O  s
   d| j vS )Nr   r   r.   r   r   r/   r/   r0   r   "  s    zRangeIndex.allc                 O  s
   t | jS r+   )anyr(   r   r/   r/   r0   r   %  s    zRangeIndex.anyc                   s2   t |tr$| j|jkr$t | |S t ||S r+   )r9   r&   r(   r   _cmp_method)r.   r   opr   r/   r0   r   *  s    zRangeIndex._cmp_methodc              
     s  t |trtS t |ttjfr,t ||S t	t
|dddrNt ||S |tjtjtjtjtjtjttjfv rt ||S d}|tjtjtjtjfv r|}t|ddd}| } z|rtjdd ||j|}W d   n1 s0    Y  t|r|s&tn|tjkr |j n|j}tjdd( ||j|}||j |}W d   n1 sb0    Y  t!| |}	t"| ||||	d}
t#d	d
 |||fD s|
$d}
|
W S  tt%t&fy   t || Y S 0 dS )z
        Parameters
        ----------
        other : Any
        op : callable that accepts 2 params
            perform the binary op
        r3   NmT)Zextract_numpyZextract_rangeignore)r   r6   c                 s  s   | ]}t |V  qd S r+   )r   re   r/   r/   r0   rs   q  rk   z+RangeIndex._arith_method.<locals>.<genexpr>r   )'r9   r   NotImplementedr   rR   Ztimedelta64r   _arith_methodr   Zis_np_dtyperp   operatorpowr   ZrpowmodZrmodfloordivZ	rfloordivdivmodZrdivmodmulZrmultruedivZrtruedivr   ZerrstaterA   r   r=   Zrsubr?   r@   r   rZ   r   astyper<   ZeroDivisionError)r.   r   r   rA   r   r   ZrstepZrstartZrstopr   rL   r   r/   r0   r   0  sN    	

*,
zRangeIndex._arith_methodr   r!   )r   
allow_fillr*   c           	      K  s  |rt d| t|r tdt|}| ||| t|dkrTtjg | j	d}n|
 }|t| krtd| dt|  | }|t|  k rtd| dt|  |j| j	dd}|dk r|t| ; }| jd	kr|| j9 }| jdkr|| j7 }| jj|| jd
S )Nr/   z!Expected indices to be array-liker   rQ   r   r   safe)Zcastingr7   r6   )r   Zvalidate_taker   r<   r   Z_maybe_disallow_fillrl   rR   arrayr3   rm   r   r   r  rA   r?   rP   r:   r5   )	r.   indicesr   r  Z
fill_valuer   ZtakenZind_maxZind_minr/   r/   r0   take|  s4    



zRangeIndex.take)NNNNFN)NN)N)F)NNN)NF)NT)NT)FT)FTr   N)F)N)NN)r   TN)KrE   
__module____qualname____doc__Z_typr   rN   __annotations__propertyr1   rC   classmethodrG   r:   r8   r   rP   rU   rV   r\   r_   rn   r?   r@   rA   ru   rw   r3   ry   r|   r}   r   r   r   r   r   r   r   r   r   r   r   r   r4   r   r   rm   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  __classcell__r/   r/   r   r0   r&   B   s   
:      $ 	
   	  	


    &.KX =O   r&   )G
__future__r   collections.abcr   r   datetimer   r   sysr   typingr   r   r	   r
   r   r   numpyrR   Zpandas._libsr   r,   r   Zpandas._libs.algosr   Zpandas._libs.libr   Zpandas.compat.numpyr   r   Zpandas.util._decoratorsr   r   r   Zpandas.core.dtypes.commonr   r   r   r   r   r   Zpandas.core.dtypes.genericr   Zpandas.corer   Zpandas.core.commoncorecommonr;   Zpandas.core.constructionr   Zpandas.core.indexes.baser   baserY   r   r   Zpandas.core.ops.commonr    Zpandas._typingr!   r"   r#   r$   r%   r'   r   r3   rT   rx   r&   r/   r/   r/   r0   <module>   s0    	 