Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/site-packages/pandas/core/indexes/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/site-packages/pandas/core/indexes/__pycache__/range.cpython-312.pyc

�

MٜgW����ddlmZddlmZmZddlmZddlZddlm	Z	ddl
mZmZm
Z
mZmZmZddlZddlmZmZddlmZdd	lmZdd
lmZddlmZm Z m!Z!ddl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd
l)m*Z*ddl+m,Z,ddl-m.cm/Z0ddl1m2Z2ddl3m.cm4cm5Z6ddl3m7Z7m8Z8ddl9m:Z:erddl;m<Z<m=Z=m>Z>m?Z?m@Z@eAd�ZBej�ej��ZEGd�de7�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����eZdZUdZdZedfZded<ded<edLd��Z							dM							dNd	�Z
edOdPd
��Ze	dQ					dRd��Z
edSd��ZedTd
��ZedUd��ZdVd�Zd�Zd�ZdWd�ZedXd��ZedXd��ZedXd��ZedXd��ZdYdZd�Zed[d��Zed\d��Zed\d��Zed\d��Zd]d�Zed^d��Z e!e"jF�dXd��Z#			d_							d`�fd�
Z$ed\d ��Z%dad!�Z&e!e"jN�dbd"��Z'e!e"jP�e)fdcd#��Z(ddd$�Z*e!e"jV�dedfd%��Z+dgd&�Z,dhdid'�Z-dhdid(�Z.djd)�Z/		dk					dld*�Z0dm�fd+�Z1e2d,d,d,d,d-�									dnd.��Z3e2d,d,d,d/�									dod0��Z3e2d,d,d,d,d-�									dpd1��Z3e4d2d3gd4�5�				dq									dp�fd6�
�Z3dYdr�fd7�
Z5dsd8�Z6dtd9�Z7dud:�Z8dv�fd;�Z9dQ�fd<�	Z:	dO	dw�fd=�
Z;dx�fd>�Z<dy�fd?�Z=dz�fd@�Z>dXdA�Z?edXdB��Z@�fdC�ZAd{dD�ZBeCdE��fdF��ZDd\dG�ZEd\dH�ZF�fdI�ZG�fdJ�ZH			d|					d}dK�ZI�xZJS)~�
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))
    []
    �
rangeindexzsigned integer�range�_range�
np.ndarray�_valuesc�"�tjS�N)�libindex�Int64Engine��selfs �D/usr/local/lib/python3.12/site-packages/pandas/core/indexes/range.py�_engine_typezRangeIndex._engine_type�s���#�#�#�c���|j|�t|||�}t||�r|j|��St|t�r|j||��St
j|||�rtd��|�t|�nd}|�d|}}nt|�}|�t|�nd}|dk(rtd��t	|||�}|j||��S)N��namez,RangeIndex(...) must be called with integersr�zStep must not be zero)�_validate_dtyper �
isinstance�copyr*�_simple_new�com�all_none�	TypeErrorr�
ValueError)�cls�start�stop�step�dtyper=r9�rngs        r4�__new__zRangeIndex.__new__�s���	���E�"�!�$��s�3���e�S�!��:�:�4�:�(�(�
��u�
%��?�?�5�t�?�4�4��<�<��t�T�*��J�K�K�,1�,=�!�%�(�1���<��U�4�E�$�T�*�D�*.�*:� ��&����1�9��4�5�5��E�4��&�����s���.�.r6c��t|t�s$t|j�dt	|��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�datar9rGs    r4�
from_rangezRangeIndex.from_range�s\��"�$��&���<�<�.�!��t�*��[�2��
�	���E�"����t�$��/�/r6c��tj|�}t|t�sJ�||_||_i|_|j�d|_|Sr/)	�objectrIr<r*r+�_name�_cache�_reset_identity�_references)rC�valuesr9�results    r4r>zRangeIndex._simple_new�sP������$���&�%�(�(�(���
������
���� �!����
r6c�Z�|�y|j\}}||�std|�d|����y)Nz#Incorrect `dtype` passed: expected z, received )�_dtype_validation_metadatarB)rCrG�validation_func�expecteds    r4r;zRangeIndex._validate_dtype�sD���=��$'�$B�$B�!����u�%��5�h�Z�{�5�'�R��
�&r6c��tS)z(return the class to use for construction)rr2s r4�_constructorzRangeIndex._constructor�s	���r6c��tj|j|j|jtj
��S)z�
        An int array that for performance reasons is created only when needed.

        The constructed array is saved in ``_cache``.
        �rG)�np�arangerDrErF�int64r2s r4�_datazRangeIndex._data�s)���y�y����T�Y�Y��	�	����J�Jr6c�l�|j}d|jfd|jfd|jfgS)z,return a list of tuples of start, stop, steprDrErF)r+rDrErF�r3rHs  r4�_get_data_as_itemszRangeIndex._get_data_as_items�s3���k�k���#�)�)�$�v�s�x�x�&8�6�3�8�8�:L�M�Mr6c��d|ji}|jt|j���tj
t
|�|fdfS)Nr9)rQ�update�dictre�ibase�
_new_Index�type)r3�ds  r4�
__reduce__zRangeIndex.__reduce__�sE��
�T�Z�Z� ��	����d�-�-�/�0�1����$�t�*�a��$�6�6r6c��td|j��}|j�0|jdt	j
|j�f�|S)zH
        Return a list of tuples of the (attr, formatted_value)
        zlist[tuple[str, str | int]]r9)rrerQ�appendri�default_pprint)r3�attrss  r4�
_format_attrszRangeIndex._format_attrssI���2�D�4K�4K�4M�N���:�:�!��L�L�&�%�"6�"6�t�z�z�"B�C�D��r6c��t|j�s|St|jd�}t|jd�}tt|�t|��}||jD�cgc]	}|d|�����c}zScc}w)Nr����<)�lenr+�str�max)r3�header�na_rep�
first_val_str�last_val_str�
max_length�xs       r4�_format_with_headerzRangeIndex._format_with_headers|���4�;�;���M��D�K�K��N�+�
��4�;�;�r�?�+����]�+�S��->�?�
��t�{�{�C�{�!�A�a�
�|�^�,�-�{�C�C�C��Cs�5Bc�.�|jjS)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+rDr2s r4rDzRangeIndex.starts�� �{�{� � � r6c�.�|jjS)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+rEr2s r4rEzRangeIndex.stop*s���{�{���r6c�.�|jjS)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+rFr2s r4rFzRangeIndex.step;s��.�{�{���r6c�\��|j�t��t�fd�dD��zS)zD
        Return the number of bytes in the underlying data.
        c3�H�K�|]}tt�|�����y�wr/)r�getattr)�.0�	attr_namerHs  �r4�	<genexpr>z$RangeIndex.nbytes.<locals>.<genexpr>Zs%�����$
�6�	�
�g�c�9�-�.�6�s�")rDrErF)r+r�sumrds @r4�nbyteszRangeIndex.nbytesTs3���
�k�k����~��$
�6�$
�!
�
�	
r6c��|jS)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_usagezRangeIndex.memory_usage_s��.�{�{�r6c��tSr/)�_dtype_int64r2s r4rGzRangeIndex.dtypexs���r6c��y)z%return if the index has unique valuesT�r2s r4�	is_uniquezRangeIndex.is_unique|s��r6c�T�|jjdkDxst|�dkS�Nrr:�r+rFrvr2s r4�is_monotonic_increasingz"RangeIndex.is_monotonic_increasing��$���{�{���!�#�5�s�4�y�A�~�5r6c�T�|jjdkxst|�dkSr�r�r2s r4�is_monotonic_decreasingz"RangeIndex.is_monotonic_decreasing�r�r6c�j�t|�	t|�}||jvS#t$rYywxYw�NF)�hashrrAr+)r3�keys  r4�__contains__zRangeIndex.__contains__�s=���S�	�	�#�C�(�C��d�k�k�!�!���	��	�s�&�	2�2c��y)N�integerr�r2s r4�
inferred_typezRangeIndex.inferred_type�s��r6c�D�t|�st|�r7|j�r't|�}	|jj	|�St|t�rt
|��|j|�t
|��#t
$r}t
|�|�d}~wwxYwr/)
rr�intr+rrB�KeyErrorr<r�_check_indexing_error)r3r��new_key�errs    r4�get_loczRangeIndex.get_loc�s����c�?�x��}����1A��#�h�G�
-��{�{�(�(��1�1��c�8�$��3�-���"�"�3�'��s�m����
-��s�m��,��
-�s�B�	B�B�Bc���tj|||�rt�|�
||||��S|jdkDr%|j
|j|j}}}n6|jddd�}|j
|j|j}}}tj|�}	|	|z
}
|
|zdk(|
dk\z|	|kz}d|
|<|
||z|
|<||jk7rt|�dz
|
|z
|
|<t|
�S)N)�method�	tolerance�limitrrtr:)r?�any_not_none�super�_get_indexerrFrDrEr+r_�asarrayrvr)
r3�targetr�r�r�rDrErF�reverse�target_array�locs�valid�	__class__s
            �r4r�zRangeIndex._get_indexer�s������F�I�u�5��7�'��v��%�(��
��9�9�q�=� $�
�
�D�I�I�t�y�y��4�E��k�k�$�B�$�'�G� '�
�
�w�|�|�W�\�\��4�E��z�z�&�)���e�#������!�d�a�i�0�L�4�4G�H����e�V���5�k�D�(��U���4�9�9���d�)�a�-�$�u�+�5�D��K�"�4�(�(r6c��y)zA
        Should an integer key be treated as positional?
        Fr�r2s r4�_should_fallback_to_positionalz)RangeIndex._should_fallback_to_positional�s��
r6c�,�t|j�Sr/)�listr+r2s r4�tolistzRangeIndex.tolist�s���D�K�K� � r6c#�8K�|jEd{���y7��wr/�r+r2s r4�__iter__zRangeIndex.__iter__�s�����;�;���s���c��|tur|jn|}|jjdk(rt	||t
j��St|�}t|�dk(r?|ddk7r7|d}t|d|d|z|�}t|�j||��S|jj||��S)N�f)r9rGr:rrtr8)
rrQrG�kindrr_�float64rrvr*rkr>r\)r3rUr9�unique_diffs�diff�	new_ranges      r4�
_shallow_copyzRangeIndex._shallow_copy�s���!�Z�/�t�z�z�T���<�<����#���d�"�*�*�=�=�%�V�,���|���!�l�1�o��&:���?�D��f�Q�i����d�):�D�A�I���:�)�)�)�$�)�?�?��$�$�0�0��d�0�C�Cr6c��t|�j|j|j��}|j|_|S)Nr8)rkr>r+rQrR)r3rVs  r4�_viewzRangeIndex._view�s3���d��'�'����$�*�*�'�E������
��
r6c�V�|j||��d}|j|��}|S)N)r9r�rr8)�_validate_names�_rename)r3r9r��	new_indexs    r4r=zRangeIndex.copy�s2���#�#��D�#�9�!�<���L�L�d�L�+�	��r6c���t|�dz
}|dk(rtjS|dk(r|jdkDs|dk(r|jdkr|jS|j|j|zzS)Nr:rt�minrrx)rvr_�nanrFrD)r3�meth�no_stepss   r4�_minmaxzRangeIndex._minmax�sc���t�9�q�=���r�>��6�6�M��e�m��	�	�A�
�4�5�=�T�Y�Y�QR�]��:�:���z�z�D�I�I��0�0�0r6c�z�tj|�tj||�|jd�S)z#The minimum value of the RangeIndexr�)�nv�validate_minmax_axis�validate_minr��r3�axis�skipna�args�kwargss     r4r�zRangeIndex.min��-��
����%�
����f�%��|�|�E�"�"r6c�z�tj|�tj||�|jd�S)z#The maximum value of the RangeIndexrx)r�r��validate_maxr�r�s     r4rxzRangeIndex.max�r�r6c��|jdd�}|jdd�tj||�|jjdkDr/tjt|�t
j��}n3tjt|�dz
ddt
j��}|s|ddd�}|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�Nrr^r:rt)	�popr��validate_argsortr+rFr_r`rv�intp)r3r�r�r�rVs     r4�argsortzRangeIndex.argsorts����J�J�{�D�1�	��
�
�6�4� �
���D�&�)��;�;���a���Y�Y�s�4�y����8�F��Y�Y�s�4�y�1�}�b�"�B�G�G�D�F���D�b�D�\�F��
r6c��tjt|�tj��}|}|r|jdkr|ddd�}|ddd�}||fS)Nr^rrt)r_r`rvr�rF)r3�sort�use_na_sentinel�codes�uniquess     r4�	factorizezRangeIndex.factorizesR��
�	�	�#�d�)�2�7�7�3�����D�I�I��M��$�B�$�K�E��d��d�m�G��g�~�r6c�t��t|t�r|j|jk(St�|�|�S)zL
        Determines if two Index objects contain the same elements.
        )r<r(r+r��equals)r3�otherr�s  �r4r�zRangeIndex.equals)s1����e�Z�(��;�;�%�,�,�.�.��w�~�e�$�$r6.��return_indexerr��na_positionr�c��yr/r��r3r�r�r�r�s     r4�sort_valueszRangeIndex.sort_values2���	r6)r�r�r�c��yr/r�r�s     r4r�zRangeIndex.sort_values=r�r6c��yr/r�r�s     r4r�zRangeIndex.sort_valuesHr�r6z3.0r3r�)�version�allowed_argsr9c�"��|�t�|�||||��S|}d}|r|jdkr$|ddd�}d}n|jdkDr
|ddd�}d}|r=|rtt	|�dz
dd�}ntt	|��}|t|�fS|S)Nr�FrrtTr:)r�r�rFr*rvr()	r3r�r�r�r��sorted_index�inverse_indexerrHr�s	        �r4r�zRangeIndex.sort_valuesSs�����?��7�&�-�#�'��	'��
� �L�#�O���9�9�q�=�#'��"��:�L�&*�O��9�9�q�=�#'��"��:�L�&*�O����C��I��M�2�r�2���C��I�&����C��0�0��r6c�f��t|t�st�|�
||��S|jdkr|j
ddd�n|j
}|jdkr|j
ddd�n|j
}t
|j|j�}t|j|j�}||kr|jt�S|j|j|j�\}}}	|j|jz
|zr|jt�S|j|j|jz
|jz|z|zz}
|j|jz|z}t|
||�}|j|�}
|
j|�}t||
j|
j�}|j|�}
|jdkxr|jdk|
jdkur|
ddd�}
|�|
j�}
|
S)N�r�rrt)r<r(r��
_intersectionrFr+rxrDr�rEr>�_empty_range�
_extended_gcdr*�_min_fitting_elementr�)r3r�r��first�second�int_low�int_high�gcd�s�_�	tmp_start�new_stepr�r��	new_startr�s               �r4r�zRangeIndex._intersection|s�����%��,��7�(��T�(�:�:�%)�Y�Y��]����D�b�D�!�����',�z�z�A�~����d��d�#�5�<�<���e�k�k�6�<�<�0���u�z�z�6�;�;�/���w���#�#�L�1�1��&�&�u�z�z�6�;�;�?�	��Q��
�K�K�&�,�,�&�#�-��#�#�L�1�1��K�K�6�<�<�%�+�+�#=����"K�s�"R�UV�"V�V�	��:�:����+�s�2���)�X�x�8�	��$�$�Y�/�	��2�2�7�;�	��)�Y�^�^�Y�^�^�D�	��$�$�Y�/�	��I�I��M�,�e�j�j�1�n�i�n�n�q�6H�I�!�$�B�$��I��<�!�-�-�/�I��r6c��||jz
t|j�z}|jt|j�|zzS)z?Returns the smallest element greater than or equal to the limit)rD�absrF)r3�lower_limitr�s   r4rzRangeIndex._min_fitting_element�s?��"�T�Z�Z�/�0�C��	�	�N�B�C���z�z�C��	�	�N�X�5�5�5r6c�x�d\}}d\}}||}}|r&||z}	|||	|zz
}}|||	|zz
}}|||	|zz
}}|r�&|||fS)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
        )rr:)r:rr�)
r3�a�br�old_s�t�old_t�r�old_r�quotients
          r4rzRangeIndex._extended_gcd�su�����5����5��a�5�����z�H��%�(�Q�,�.�1�E��%�(�Q�,�.�1�E��%�(�Q�,�.�1�E�	�
�e�U�"�"r6c���|sy|jsyt|�dkDr$|j|jjzry|j|jvxr|d|jvS)z)Check if other range is contained in selfTFr:rt)r+rvrFrD)r3r�s  r4�_range_in_selfzRangeIndex._range_in_self�s\�����{�{���u�:��>�e�j�j�4�;�;�+;�+;�;���{�{�d�k�k�)�F�e�B�i�4�;�;�.F�Fr6c����t|t��rO|dvs1|du�rF|jdkD�r6|j|j��r|j
|j}}|j
|jt
|�dz
zz}|j
|j}}|j
|jt
|�dz
zz}|jdkr|||}}}|jdkr|||}}}t
|�dk(r3t
|�dk(r%t|j
|j
z
�x}}n!t
|�dk(r|}nt
|�dk(r|}t||�}	t||�}
||k(r}||z
|zdk(r&||z
|kr||z
|krt|�|	|
|z|�S|dzdk(r�t||z
�|dzk(r�t||z
�|dzk(r�t|�|	|
|dzz|dz�S||zdk(r1||z
|zdk(r_||z|k\rW||z
|krOt|�|	|
|z|�S||zdk(r1||z
|zdk(r&||z|k\r||z
|krt|�|	|
|z|�St�|�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
        �NTFrr:�r�)
r<r(rFrr+rDrvr
r�rxrkr��_union)r3r�r��start_s�step_s�end_s�start_o�step_o�end_o�start_r�end_rr�s           �r4rzRangeIndex._union�s����(�e�Z�(��|�#���
�$�)�)�a�-�D�4G�4G����4U�#'�*�*�d�i�i����
�
�T�Y�Y�#�d�)�a�-�%@�@��"'�+�+�u�z�z������e�j�j�C��J��N�&C�C���9�9�q�=�-2�V�G�W�U�V�G��:�:��>�-2�V�G�W�U�V�G��t�9��>�c�%�j�A�o�&)�$�*�*�u�{�{�*B�&C�C�F�V���Y�!�^�#�F���Z�1�_�#�F��g�w�/���E�5�)���V�#� �7�*�f�4��9�$�u�_��7�$�u�_��7�)�t�D�z�'�5�6�>�6�J�J��!��q�� ��7�!2�3�v��z�A� ����/�6�A�:�=� *�t�D�z�'�5�6�A�:�3E�v�PQ�z�R�R��f�_��)� �7�*�f�4��9�$�v�-��8�"�V�^�u�4�)�t�D�z�'�5�6�>�6�J�J��f�_��)� �7�*�f�4��9�$�v�-��8�"�V�^�u�4�)�t�D�z�'�5�6�>�6�J�J��w�~�e�$�~�/�/r6c���|j|�|j|�|j|�\}}t|t�st
�
|�||��S|dur&|jdkr|ddd�j
|�Stj||�}|jdkr|jddd�n|j}|j|�}|jdkr|ddd�}t|�dk(r|j|��St|�t|�k(r|ddj|�St|�dk(rR|d|dk(r|ddS|d|dk(r|ddSt|�dk(r|d|dk(r|ddd�St
�
|�||��St|�dk(r|d|dk(r|d|dk(r|ddS|j|jk(r�|d|jk(r2t|d|jz|j |j�}n�|d|dk(r%t|j|d|j�}n�|j|ddk(rt|�dz
}|dd|�}n�t
�
|�||��St|�dkDsJ�|j|jdzk(rW|d|dk(r|d|d|d	fvr	|ddd�}nE|d|dk(r|d|d|d	fvr	|ddd�}n"t
�
|�||��St
�
|�||��St#|�j%||��}	||jur|	ddd�}	|	S)
Nr�Frrtr8r:�r���)�_validate_sort_keyword�_assert_can_do_setop�_convert_can_do_setopr<r(r��_differencerFr�get_op_result_namer+�intersectionrv�renamerDr*rErkr>)r3r�r��result_name�res_namer�overlap�new_rngrFr�r�s          �r4r,zRangeIndex._differences�����#�#�D�)��!�!�%�(�!�7�7��>���{��%��,��7�&�u�4�&�8�8��u�����Q����"��:�)�)�%�0�0��)�)�$��6��%)�Y�Y��]����D�b�D�!������#�#�E�*���<�<�!���d��d�m�G��w�<�1���;�;�H�;�-�-��w�<�3�t�9�$����8�?�?�8�,�,��w�<�1���q�z�T�!�W�$��A�B�x�����t�B�x�'��C�R�y� ��T��a��G�A�J�$�q�'�$9��C�a�C�y� ��w�*�5�t�*�<�<�
��\�Q�
�7�1�:��q��#9�g�b�k�U�SU�Y�>V���"�:���<�<�5�:�:�%��q�z�U�[�[�(�����e�j�j� 8�%�*�*�e�j�j�Q������b�	�)�����W�Q�Z����D�����5��2�;�.��5�z�A�~����$��-���w�*�5�t�*�<�<�
�t�9�q�=� �=��|�|�u�z�z�A�~�-��1�:��q��)�g�b�k�e�B�i��r��=S�.S�#�A�D�q�D�k�G��Q�Z�5��8�+�����b�	�5�QS�9�?U�0U�#�C�a�C�j�G�!�7�.�u�4�.�@�@��w�*�5�t�*�<�<���J�*�*�7��*�B�	�����#�!�$�B�$��I��r6c����t|t�r|�t�|�
|||�S|j	|�}|j	|�}|j|�}|�|j
|�}|Sr/)r<r(r��symmetric_difference�
difference�unionr/)r3r�r0r��left�rightrVr�s       �r4r5zRangeIndex.symmetric_differencemsm����%��,��0@��7�/��{�D�I�I����u�%��� � ��&�����E�"���"��]�]�;�/�F��
r6c����t|�rF|dt|�fvr|ddS|dt|�dz
fvr|ddSt|�dk(r�|dvr�|ddd�Stj|�rjtjtj|t
j��t|��}t|t�r||}|j|d�	�St�|�1|�S)
Nrr:rtr')r:r(rr^Fr�)
rrvr�is_list_like�maybe_indices_to_slicer_r�r�r<�slicer6r��delete)r3�loc�slcr�r�s    �r4r>zRangeIndex.deletes�����c�?��q�3�t�9�*�o�%��A�B�x���r�3�t�9�q�=�)�)��C�R�y� ��4�y�A�~�#��.��C�a�C�y� �
�
�
�c�
"��,�,�R�Z�Z��2�7�7�-K�S�QU�Y�W�C��#�u�%��S�	�����u�5��9�9��w�~�c�"�"r6c�~��t|��r�t|�st|��r�|j}|dk(rs||d|jz
k(r^t|j|jz
|j|j�}t|�j||j��S|t|�k(rs||d|jzk(r^t|j|j|jz|j�}t|�j||j��St|�dk(rw||d|jdzzk(r_t|jdz�}t|j|j|�}t|�j||j��St�|�5||�S)Nrr8rtr)rvrrr+rFr*rDrErkr>rQr�r��insert)r3r?�itemrHr3rFr�s      �r4rBzRangeIndex.insert�sY����t�9�*�T�*�h�t�n��+�+�C��a�x�D�D��G�d�i�i�$7�7���	�	�C�H�H� 4�c�h�h����I���D�z�-�-�g�D�J�J�-�G�G���D�	�!�d�d�2�h����.B�&B���	�	�3�8�8�c�h�h�+>����I���D�z�-�-�g�D�J�J�-�G�G��T��a��D�D��G�d�i�i�!�m�,C�$C��4�9�9�q�=�)����
�
�D�I�I�t�<���D�z�-�-�g�D�J�J�-�G�G��w�~�c�4�(�(r6c	���td�|D��st�|�	||�St|�dk(r|dSt	t
t|�}dx}x}}|D�cgc]}t|�s�|��}}|D�]>}|j}	|�)|	j}|��t|	�dkDr~|	j}nq|�o|	j|k(rQtj|D�
cgc]}
|
j��c}
�}|j|�}|j|�cS|	j|z
}||	jk7xrt|	�dkDxs|duxr|	j|k7}
|
rO|jtj|D�
cgc]}
|
j��c}
��}|j|�cS|���7|	d|z}��A|r/|�|djn|}t
|||�j|�St
dd�j|�Scc}wcc}
wcc}
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')
        c3�<K�|]}t|t����y�wr/)r<r(�r�r~s  r4r�z%RangeIndex._concat.<locals>.<genexpr>�s����>�g��:�a��,�g�s�r:rNrt)�allr��_concatrvrr�r(r+rDrFr_�concatenater-r\r/rE)r3�indexesr9�rng_indexesrDrF�next_�obj�non_empty_indexesrHr~rUrV�non_consecutiverEr�s               �r4rHzRangeIndex._concat�s����>�g�>�>��7�?�7�D�1�1�
��\�Q�
��1�:���4�
�+�W�5��#�#��#��u�-8�D�K�S�3�s�8�S�K��D�$�C��*�*�C��}��	�	���<�C��H�q�L��8�8�D����9�9��%��^�^��,L��1�Q�Y�Y��,L�M�F�!�.�.�v�6�F�!�=�=��.�.��y�y�5�(��#�s�x�x�/�@�C��H�q�L���T�!�8�c�i�i�5�&8�
���*�*��N�N�{�#C�{�!�A�I�I�{�#C�D����}�}�T�*�*����B��$���7%�:�27��$�R�(�-�-�E�D��e�T�4�0�7�7��=�=��!�Q��&�&�t�,�,��OE��-M��$Ds�G?�)G?�H
�3H	c�,�t|j�S)z5
        return the length of the RangeIndex
        )rvr+r2s r4�__len__zRangeIndex.__len__�s���4�;�;��r6c��t|�Sr/)rvr2s r4�sizezRangeIndex.size�s���4�y�r6c	�4��t|t�r|j|�St|�rt	|�}	|j
|St|�rt
d��t�|�)|�S#t$r }t
d|�dt|����|�d}~wwxYw)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_slicerr�r+�
IndexErrorrvrr��__getitem__)r3r�r�r�r�s    �r4rYzRangeIndex.__getitem__�s�����c�5�!��&�&�s�+�+�
��_��#�h�G�
��{�{�7�+�+�
�s�^��+��
��w�"�3�'�'���
� ��S�E�!H��T���T�����
�s�A.�.	B�7B�Bc�l�|j|}t|�j||j��S)zH
        Fastpath for __getitem__ when we know we have a slice.
        r8)r+rkr>rQ)r3�slobj�ress   r4rWzRangeIndex._getitem_slices0���k�k�%� ���D�z�%�%�c��
�
�%�;�;r6�__floordiv__c����t|�r�|dk7r�t|�dk(s$|j|zdk(ro|j|zdk(r]|j|z}|j|z}|t|�|zz}t	|||xsd�}|j||j��St|�dk(r<|j|z}t	||dzd�}|j||j��St�|�!|�S)Nrr:r8)	rrvrDrFr*r>rQr�r])r3r�rDrFrEr�r�s      �r4r]zRangeIndex.__floordiv__s�����e���!���4�y�A�~����e�!3�q�!8�T�Y�Y��=N�RS�=S��
�
�e�+���y�y�E�)���s�4�y�4�/�/��!�%��t�y�q�9�	��'�'�	��
�
�'�C�C��4�y�A�~��
�
�e�+��!�%����A�6�	��'�'�	��
�
�'�C�C��w�#�E�*�*r6c��d|jvS)Nrr��r3r�r�s   r4rGzRangeIndex.all"s������#�#r6c�,�t|j�Sr/)�anyr+r`s   r4rbzRangeIndex.any%s���4�;�;��r6c���t|t�r)|j|jk(rt�|�||�St�|�||�Sr/)r<r(r+r��_cmp_method)r3r��opr�s   �r4rdzRangeIndex._cmp_method*s@����e�Z�(�T�[�[�E�L�L�-H��7�&�t�R�0�0��w�"�5�"�-�-r6c	�:��t|t�rtSt|ttj
f�rt�|�||�Stjt|dd�d�rt�|�||�S|tjtjtjtj tj"tj$t&tj(fvrt�|�||�Sd}|tj*tj,tj.tj0fvr|}t3|dd��}|}	|rEt	j4d��5||j6|�}ddd�t9�r|s2t:�|tj<k(r
|j6n|j6}t	j4d��5||j>|�}||j@|�}ddd�tjB||�}	tE|�||	��}
tGd	�|||fD��s|
jId
�}
|
S#1swY��xYw#1swY�hxYw#t:tJtLf$rt�|�||�cYSwxYw)z�
        Parameters
        ----------
        other : Any
        op : callable that accepts 2 params
            perform the binary op
        rGN�mT)�
extract_numpy�
extract_range�ignore)rGr8c3�2K�|]}t|����y�wr/)rrFs  r4r�z+RangeIndex._arith_method.<locals>.<genexpr>qs����E�.D��z�!�}�.D�s�r�)'r<r�NotImplementedrr_�timedelta64r��
_arith_methodr�is_np_dtyper��operator�powr�rpow�mod�rmod�floordiv�	rfloordiv�divmod�rdivmod�mul�rmul�truediv�rtruedivr�errstaterFrrB�rsubrDrEr-rkrG�astyperA�ZeroDivisionError)r3r�rerFr9r8�rstep�rstart�rstopr1rVr�s           �r4rnzRangeIndex._arith_method0s����e�.�/�!�!�
��	�2�>�>�:�
;��7�(���3�3�
�_�_�W�U�G�T�:�C�
@��7�(���3�3�
��L�L��H�H��L�L��H�H�����M�M���K�K�	
�	
��7�(���3�3� $��
�(�,�,����(�*:�*:�C�L�L�I�I��D��e�4�t�L���� 	4���[�[�X�.� ����E�2�E�/�
"�%�(��$�$�')�C�H�H�n����
�$�)�)������*��D�J�J��.���4�9�9�e�,��+��-�-�d�E�:�H��T�$�Z���u�8�D�F�
�E�v�u�e�.D�E�E����y�1���M�3/�.��+�*���I�'8�9�	4��7�(���3�3�	4�sD�I3�(I�<AI3�'I'�AI3�I$� I3�'I0�,I3�3$J�Jc��|rtjd|�t|�rtd��t	|�}|j|||�t
|�dk(r"tjg|j��}n�|j�}|t
|�k\rtd|�dt
|�����|j�}|t
|�krtd|�dt
|�����|j|jd��}|dkr|t
|�z}|jd	k7r||jz}|jdk7r||jz
}|j j#||j$�
�S)Nr�z!Expected indices to be array-likerr^rUrV�safe)�castingr:r8)r��
validate_takerrAr�_maybe_disallow_fillrvr_�arrayrGrxrXr�rrFrDr\r>r9)	r3�indicesr��
allow_fill�
fill_valuer��taken�ind_max�ind_mins	         r4�takezRangeIndex.take|sb������R��(��W���?�@�@�%�g�.��	
�!�!�*�j�'�B��w�<�1���H�H�R�t�z�z�2�E��k�k�m�G��#�d�)�#� ��W�I�%L�S�QU�Y�K�X����k�k�m�G��#�d�)��#� ��W�I�%L�S�QU�Y�K�X����N�N�4�:�:�v�N�>�E���{���T��"���y�y�A�~�����"���z�z�Q������#��� � �,�,�U����,�C�Cr6)�returnztype[libindex.Int64Engine])NNNNFN)rG�Dtype | Noner=�boolr9�Hashable | Noner�r%)NN)rMr*rGr�r�r%r/)rUr*r9r�r�r%)rGr�r��None)r�ztype[Index])r�r,)r�zlist[tuple[str, int]])ry�	list[str]rzrwr�r�)r�r�)F)r�r�r�r�)r�znp.dtype)r�r�)r�r	r�r�)r�rw)NNN)r�rr�z
str | Noner�z
int | Noner��npt.NDArray[np.intp])r�z	list[int])r�z
Iterator[int])r9r)r�r%r�)r9r�r�r�r�r%)r�rwr)r�r�r�r�)r�r�)FT)r�r�r�r�r�z'tuple[npt.NDArray[np.intp], RangeIndex])r�rPr�r�)
r�zLiteral[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�rr�r�)rr�r�r�)rr�rr�r�ztuple[int, int, int])r�r*r�r�)r�rr�zbool | None)r0r�)r�r)r?r�r�r)rJzlist[Index]r9rr�r)r[r=r�r%)rTN)r�r"r�r�r�r)KrK�
__module__�__qualname__�__doc__�_typrrX�__annotations__�propertyr5rI�classmethodrNr>r;rr\rbrermrrrrDrErFr�r�rGr�r�r�r�r�rrr�r�r�r�r�r�rr�r=r�r�rxr�r�r�r
r�rr�rrrrr,r5r>rBrHrQrSrYrWr!r]rGrbrdrnr��
__classcell__)r�s@r4r(r(Bs���8�t�D�"9�;K�!L���M�
��
�$��$��
�
�"�� $�"/�
�"/��
"/��"/�
�"/�H�0��0�6�48����"1��	
������������
�K��K�N�
7��D��!��!�"� �� � � �� �0�
��
��2���������6��6��6��6�"�����	�����
��
�"� ��)��)��)��	)�
�
)�<����!�	��������	��	�	��5?�
D��
D��
	����_����
1�#�#��8� $�
��
��
�
1�	
�%��*-��"%�"�
�'���	�
 ���
�
�����
�"%�"�
�&���	�
 ���
�
.����� #��"%�"�
����	�
 ���
�
5����$��V�H�=��
 %��"(�#�! ��! ��! � �	! �
�! �
5�
! ��! �L,�\6�
#�"	G�I0�VU�p@D��"1��$#�,)�*;-�z �����(�.<��n�-�
+�.�
+�$$� �
.�H4�^���'D��'D��	'D�
�'Dr6r()G�
__future__r�collections.abcrr�datetimerrp�sysr�typingrr	r
rrr
�numpyr_�pandas._libsrr0r�pandas._libs.algosr�pandas._libs.libr�pandas.compat.numpyrr��pandas.util._decoratorsrrr�pandas.core.dtypes.commonrrrrrr�pandas.core.dtypes.genericr�pandas.corer�pandas.core.common�core�commonr?�pandas.core.constructionr�pandas.core.indexes.baserJ�baserirr �pandas.core.ops.commonr!�pandas._typingr"r#r$r%r&r*r�rGrar�r(r�r6r4�<module>r�s���"���������-�'�.�����9�� � �2�(�(��<�����Q�x���r�x�x����!��aD��aDr6

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists