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__/interval.cpython-312.pyc

�

Mٜg.���h�dZddlmZddlmZmZddlZddlmZm	Z	m
Z
ddlZddl
mZddlmZmZmZddlmZmZmZmZmZdd	lmZdd
lmZmZddlmZddl m!Z!m"Z"m#Z#m$Z$m%Z%dd
l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddl<m=cm>Z?ddl@mAZAddlBm=cmCcmDZEddlBmFZFmGZGmHZHmIZIddlJmKZKmLZLddlMmNZNmOZOddlPmQZQddlRmSZSmTZTerddlUmVZVddlWmXZXmYZYmZZZm[Z[m\Z\e]eEj��Z^e^j�dddej�d�d��d�Zad �Zbd!�Zcee;d"dd#e^d$d%d&ej�d'�d(�z�eOd)d*ge:d+�,�eOgd-�e:�eOd.d/ge:d+�0�Gd1�deN�����Zdd5d2�Zed5d3�Zf						d6					d7d4�Zgy)8z define the IntervalIndex �)�annotations)�le�ltN)�
TYPE_CHECKING�Any�Literal)�lib)�Interval�
IntervalMixin�IntervalTree)�
BaseOffset�Period�	Timedelta�	Timestamp�	to_offset)�InvalidIndexError)�Appender�cache_readonly)�rewrite_exception)�find_common_type�infer_dtype_from_scalar�maybe_box_datetimelike�maybe_downcast_numeric�maybe_upcast_numeric_to_64bit)	�ensure_platform_int�is_float_dtype�
is_integer�is_integer_dtype�is_list_like�	is_number�is_object_dtype�	is_scalar�pandas_dtype)�DatetimeTZDtype�
IntervalDtype)�is_valid_na_for_dtype��unique)�validate_periods)�
IntervalArray�_interval_shared_docs)�is_valid_positional_slice)�Index�_index_shared_docs�ensure_index�maybe_extract_name)�
DatetimeIndex�
date_range)�ExtensionIndex�
inherit_names)�
MultiIndex)�TimedeltaIndex�timedelta_range)�Hashable)�Dtype�DtypeObj�IntervalClosedType�Self�npt�
IntervalIndexz"IntervalIndex or list of IntervalszX         name : object, optional
              Name to be stored in the index.
         )�klass�qualname�target_klass�namec��t|dt|��}t|ttf�rd}t|�}t
j|d�st|t�r|tjdd�zSt|�r|dzSt|�r$tj|tj�Stdt!t|�������N�dtypezdatetime64[ns]�mM��nsz%cannot determine next label for type ��getattr�type�
isinstancerrr#r	�is_np_dtyper$�np�timedelta64rr�	nextafter�inf�	TypeError�repr��labelrEs  �G/usr/local/lib/python3.12/site-packages/pandas/core/indexes/interval.py�_get_next_labelrWus����E�7�D��K�0�E��%�)�Y�/�0� �����E�
���u�d�#�z�%��'I��r�~�~�a��.�.�.�	�%�	 ��q�y��	��	��|�|�E�2�6�6�*�*��?��T�%�[�@Q�?R�S�T�T�c��t|dt|��}t|ttf�rd}t|�}t
j|d�st|t�r|tjdd�z
St|�r|dz
St|�r%tj|tj�Stdt!t|������rDrIrTs  rV�_get_prev_labelrZ�s����E�7�D��K�0�E��%�)�Y�/�0� �����E�
���u�d�#�z�%��'I��r�~�~�a��.�.�.�	�%�	 ��q�y��	��	��|�|�E�B�F�F�7�+�+��?��T�%�[�@Q�?R�S�T�TrXc�&�|jdi|��S)zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    �)�from_arrays)�cls�ds  rV�_new_IntervalIndexr`�s��
�3�?�?��Q��rX�classz>Immutable index of intervals that are closed on the same side.rBzis_overlapping
values
�a7    Examples
    --------
    A new ``IntervalIndex`` is typically constructed using
    :func:`interval_range`:

    >>> pd.interval_range(start=0, end=5)
    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
                  dtype='interval[int64, right]')

    It may also be constructed using one of the constructor
    methods: :meth:`IntervalIndex.from_arrays`,
    :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`.

    See further examples in the doc strings of ``interval_range`` and the
    mentioned constructor methods.
    )r?�summaryrB�extra_attributes�
extra_methods�examples�
set_closed�	to_tuplesT)�wrap)�	__array__�overlaps�contains�closed_left�closed_right�	open_left�
open_right�is_empty�is_non_overlapping_monotonic�closed)�cachec	�j��eZdZUdZded<ded<ded<ded<ded<ded	<d
ed<d
ed<d
ZeZ					d<											d=d�Ze	e
eddejd�ejd�d�z�				d>									d?d���Ze	e
eddejd�ejd�d�z�				d>									d@d���Ze	e
eddejd�ejd�d�z�				d>									d@d���ZedAd��ZdBd�ZdCd�ZedDd��Zd�ZedEd��Ze
ej4j6�dFdGd ��ZedHd!��ZedHd"��ZedHd#��ZdHd$�Zd%�Z dIdJd&�Z!dKd'�Z"			dL									dMd(�Z#e
e$d)e%z�				dNd*��Z&dOd+�Z'				dNd,�Z(edHd-��Z)d.Z*dP�fd/�Z+edHd0��Z,dQd1�Z-dRd2�Z.edSd3��Z/edSd4��Z0edSd5��Z1edSd6��Z2d7�Z3dTd8�Z4dTd9�Z5dUd:�Z6d;�Z7�xZ8S)Vr>�
intervalindexr;rs�boolrrrmrnrorpr*�_data�_valuesFc��t|||�}td|j�5t|||||��}ddd�|j	|�S#1swY�xYw)Nr*)rs�copyrE�verify_integrity)r0r�__name__r*�_simple_new)r^�datarsrEr{rBr|�arrays        rV�__new__zIntervalIndex.__new__�sZ��"�$��c�2��
�����
=�!�����!1��E�>����u�d�+�+�>�
=�s�A�A�from_breakszY
             name : str, optional
                  Name of the resulting IntervalIndex.z�        Examples
        --------
        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        )r?rBrfc��td|j�5tj||||��}ddd�|j	|��S#1swY�xYw�Nr*)rsr{rE�rB)rr}r*r�r~)r^�breaksrsrBr{rEr�s       rVr�zIntervalIndex.from_breaks�sN��:�����
=�!�-�-��v�D���E�>����u�4��0�0�	>�
=���A�Ar]z�        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        c��td|j�5tj|||||��}ddd�|j	|��S#1swY�xYw)Nr*)r{rEr�)rr}r*r]r~)r^�left�rightrsrBr{rEr�s        rVr]zIntervalIndex.from_arrayssP��<�����
=�!�-�-��e�V�$�e��E�>����u�4��0�0�	>�
=�s�A
�
A�from_tuplesz�        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        c��td|j�5tj||||��}ddd�|j	|��S#1swY�xYwr�)rr}r*r�r~)r^rrsrBr{rE�arrs       rVr�zIntervalIndex.from_tuples;sJ��:�����
=��+�+�D��d�RW�X�C�>����s���.�.�>�
=�r�c���|j|j�}t|�}|j|j�}t|�}t	|||j
��S)N�rs)�_maybe_convert_i8r�rr�rrs)�selfr�r�s   rV�_enginezIntervalIndex._engine_sS���%�%�d�i�i�0��,�T�2���&�&�t�z�z�2��-�e�4���D�%����<�<rXc���t|�t|t�s#t||j�r|j
Sy	|j
|�y#t$rYywxYw)z�
        return a boolean if this key is IN the index
        We *only* accept an Interval

        Parameters
        ----------
        key : Interval

        Returns
        -------
        bool
        FT)�hashrLr
r&rE�hasnans�get_loc�KeyError)r��keys  rV�__contains__zIntervalIndex.__contains__hsV��	
�S�	��#�x�(�$�S�$�*�*�5��|�|�#��	��L�L������	��	�s�A�	A�Ac�l�|j|}t|�j||j��S)zH
        Fastpath for __getitem__ when we know we have a slice.
        r�)rxrKr~�_name)r��slobj�ress   rV�_getitem_slicezIntervalIndex._getitem_slice�s0���j�j�����D�z�%�%�c��
�
�%�;�;rXc�`�tj|j|jgddg��S)Nr�r�)�names)r5r]r�r��r�s rV�_multiindexzIntervalIndex._multiindex�s'���%�%�t�y�y�$�*�*�&=�f�g�EV�W�WrXc��|j|j|j|jd�}tt|�|fdfS)N)r�r�rsrB)r�r�rsrBr`rK)r�r_s  rV�
__reduce__zIntervalIndex.__reduce__�s<���I�I��Z�Z��k�k��I�I�	
��"�D��J��?�D�8�8rXc��y)z4Return a string of the type inferred from the values�intervalr\r�s rV�
inferred_typezIntervalIndex.inferred_type�s��rXc�t�|jj|��|jj|��zS)N)�deep)r��memory_usager�)r�r�s  rVr�zIntervalIndex.memory_usage�s4���y�y�%�%�4�%�0�4�:�:�3J�3J�PT�3J�3U�U�UrXc�&�|ddd�jS)z�
        Return True if the IntervalIndex is monotonic decreasing (only equal or
        decreasing values), else False
        N���)�is_monotonic_increasingr�s rV�is_monotonic_decreasingz%IntervalIndex.is_monotonic_decreasing�s���D�b�D�z�1�1�1rXc�^�|j}|j}|j�j�dkDry|js|jryt�}t
j|jd���d}|D]#}||||f}||vry|j|��%y)zX
        Return True if the IntervalIndex contains unique elements, else False.
        rGFT)�keepr)
r�r��isna�sum�	is_unique�setrN�where�
duplicated�add)r�r�r��
seen_pairs�	check_idx�idx�pairs       rVr�zIntervalIndex.is_unique�s���
�y�y���
�
���9�9�;�?�?��q� ���>�>�U�_�_���U�
��H�H�T�_�_�%�_�8�9�!�<�	��C���I�u�S�z�*�D��z�!���N�N�4� �	�rXc�.�|jjS)a�
        Return True if the IntervalIndex has overlapping intervals, else False.

        Two intervals overlap if they share a common point, including closed
        endpoints. Intervals that only have an open endpoint in common do not
        overlap.

        Returns
        -------
        bool
            Boolean indicating if the IntervalIndex has overlapping intervals.

        See Also
        --------
        Interval.overlaps : Check whether two Interval objects overlap.
        IntervalIndex.overlaps : Check an IntervalIndex elementwise for
            overlaps.

        Examples
        --------
        >>> index = pd.IntervalIndex.from_tuples([(0, 2), (1, 3), (4, 5)])
        >>> index
        IntervalIndex([(0, 2], (1, 3], (4, 5]],
              dtype='interval[int64, right]')
        >>> index.is_overlapping
        True

        Intervals that share closed endpoints overlap:

        >>> index = pd.interval_range(0, 3, closed='both')
        >>> index
        IntervalIndex([[0, 1], [1, 2], [2, 3]],
              dtype='interval[int64, both]')
        >>> index.is_overlapping
        True

        Intervals that only have an open endpoint in common do not overlap:

        >>> index = pd.interval_range(0, 3, closed='left')
        >>> index
        IntervalIndex([[0, 1), [1, 2), [2, 3)],
              dtype='interval[int64, left]')
        >>> index.is_overlapping
        False
        )r��is_overlappingr�s rVr�zIntervalIndex.is_overlapping�s��`�|�|�*�*�*rXc���t|dd�}t|t�st|t�r|j	|j
�Sttttf}t||�S)a	
        Check if a given key needs i8 conversion. Conversion is necessary for
        Timestamp, Timedelta, DatetimeIndex, and TimedeltaIndex keys. An
        Interval-like requires conversion if its endpoints are one of the
        aforementioned types.

        Assumes that any list-like data has already been cast to an Index.

        Parameters
        ----------
        key : scalar or Index-like
            The key that should be checked for i8 conversion

        Returns
        -------
        bool
        rEN)
rJrLr%r
�_needs_i8_conversionr�rrr1r6)r�r��	key_dtype�i8_typess    rVr�z"IntervalIndex._needs_i8_conversion�sU��$�C��$�/�	��i��/�:�c�8�3L��,�,�S�X�X�6�6��y�-��H���#�x�(�(rXc��t|�rt|�}t|�}|j|�s|St	|�}t|dd�}t
|t�st
|t�rc|j|j�}|j|j�}|rtntj}||||j��S|r�t|�\}}t
|t �r
|j"}n�t
|t$�r
|j&}n�t
|t(j*t(j,f�r[|j/d�}nI|j0t3|j4�}}|j6r|j9|j:�}|j0j<}||k7rt?d|�d|����|S)a
        Maybe convert a given key to its equivalent i8 value(s). Used as a
        preprocessing step prior to IntervalTree queries (self._engine), which
        expects numeric data.

        Parameters
        ----------
        key : scalar or list-like
            The key that should maybe be converted to i8.

        Returns
        -------
        scalar or list-like
            The original key if no conversion occurred, int if converted scalar,
            Index with an int64 dtype if converted list-like.
        rENr��i8z)Cannot index an IntervalIndex of subtype z with values of dtype ) rr/rr�r"rJrLr%r
r�r�r�r>r]rsrr�ordinalr�_valuerN�
datetime64rO�viewrEr-�asi8r�r��_isnan�subtype�
ValueError)	r�r��scalarr�r�r��constructor�key_i8r�s	         rVr�zIntervalIndex._maybe_convert_i8s���"����s�#�C�/��4�C��(�(��-��J��3����C��$�/�	��i��/�:�c�8�3L��)�)�#�(�(�3�D��*�*�3�9�9�5�E�&,�(�-�2K�2K�K���e�D�K�K��
�� 7�� <��I�v��#�v�&������F�I�.������F�R�]�]�B�N�N�$C�D����T�*��!$�	�	�5����?�v�I��{�{� ���s�z�z�k�2��
�*�*�$�$���i���;�G�9�E#�#,�+�/��
�
�
rXc��|jstd��t|ttf�rtd��|dk(r|jjs|dk(r:|jjs$|j}|jr/t|�}n#|j}|jrt|�}|j||�S)Nzrcan only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasingz,Interval objects are not currently supportedr�r�)rrr�rLrr>�NotImplementedErrorr�r�r�rprWrorZ�_searchsorted_monotonic)r�rU�side�sub_idxs    rVr�z%IntervalIndex._searchsorted_monotonicPs����0�0��M��
�
�e�m�]�;�<�%�&T�U�U�

�F�N�t�y�y�@�@��G�O�D�I�I�$E�$E��j�j�G����'��.���i�i�G��~�~�'��.���.�.�u�d�;�;rXc�n�|j|�t|t�rX|j|jk7rt	|��|j
|j
k(|j|jk(z}nt||j�r|j�}nX|jrtnt}|jrtnt}	||j
|�|||j�z}|j�}|dk(rt	|��|dk(r|j!�St#j$|j'd��}t|t(�r6|j*�*t)|j,t/|�|j0�}|S#t$r}t	|�|�d}~wwxYw)a�
        Get integer location, slice or boolean mask for requested label.

        Parameters
        ----------
        key : label

        Returns
        -------
        int if unique index, slice if monotonic index, else mask

        Examples
        --------
        >>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
        >>> index = pd.IntervalIndex([i1, i2])
        >>> index.get_loc(1)
        0

        You can also supply a point inside an interval.

        >>> index.get_loc(1.5)
        1

        If a label is in several intervals, you get the locations of all the
        relevant intervals.

        >>> i3 = pd.Interval(0, 2)
        >>> overlapping_index = pd.IntervalIndex([i1, i2, i3])
        >>> overlapping_index.get_loc(0.5)
        array([ True, False,  True])

        Only exact matches will be returned if an interval is provided.

        >>> index.get_loc(pd.Interval(0, 1))
        0
        NrrG�u1)�_check_indexing_errorrLr
rsr�r�r�r&rEr�rmrrrnrRr��argmaxr	�maybe_booleans_to_slicer��slice�stop�start�len�step)r�r��mask�op_left�op_right�err�matchesr�s        rVr�zIntervalIndex.get_locmsR��J	
�"�"�3�'��c�8�$��{�{�c�j�j�(��s�m�#��I�I����)�d�j�j�C�I�I�.E�F�D�
"�3��
�
�
3��9�9�;�D�!�,�,�b�"�G�!�.�.�r�B�H�
-��t�y�y�#�.��#�t�z�z�1J�J��
�(�(�*���a�<��3�-���a�<��;�;�=� ��)�)�$�)�)�D�/�:���c�5�!�c�h�h�&6���	�	�3�t�9�c�h�h�7�C��
���
-��s�m��,��
-�s�'F�	F4�#F/�/F4c�.�t|t�r|j|�}t|�St|j�sA|j|�}|jj|j�}t|�S|j|�dS)Nr)rLr>�_get_indexer_unique_sidesr!rEr�r��get_indexer�values�_get_indexer_pointwiser)r��target�method�limit�	tolerance�indexers      rV�_get_indexerzIntervalIndex._get_indexer�s����f�m�,�
�4�4�V�<�G�#�7�+�+�!����.��+�+�F�3�F��l�l�.�.�v�}�}�=�G�#�7�+�+��.�.�v�6�q�9�9rX�get_indexer_non_uniquec�z�t|�}|j|�s%|j|�s|j|dd��St	|t
�re|jjr>|jjr(|j|�}|dk(j�d}n�|j|�St|j�s|j|�s|j|�S|j|�}|jj!|j"�\}}t%|�t%|�fS)NFr'r�r)r/�_should_compare�_should_partial_index�_get_indexer_non_comparablerLr>r�r�r�r��nonzeror�r!rEr�r�r�r�r)r�r�r��missings    rVr�z$IntervalIndex.get_indexer_non_unique�s
���f�%���#�#�F�+�D�4N�4N�v�4V��3�3�F�D��3�O�O�
��
�
.��y�y�"�"�t�z�z�';�';��8�8��@��"�b�=�1�1�3�A�6���2�2�6�:�:�
�V�\�\�
*�$�2L�2L�V�2T��.�.�v�6�6�
�+�+�F�3�F�#�|�|�B�B�6�=�=�Q��G�W�"�7�+�-@��-I�I�IrXc���|jj|j�}|jj|j�}tj||k(|d�}|S)zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r�)r�r�r�rNr�)r�r��left_indexer�
right_indexerr�s     rVr�z'IntervalIndex._get_indexer_unique_sides�sP���y�y�,�,�V�[�[�9���
�
�.�.�v�|�|�<�
��(�(�<�=�8�,��K���rXc��gg}}t|�D]�\}}	|j|�}t|t�r8t	j
|j|j|jd��}nEtj|�rt	j|d��}nt	j|�d}|j|���t	j |�}t#|�t#|�fS#t$r*|j|�t	jdg�}Y�pt$r*|j|�t	jdg�}Y��wxYw)zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        �intp�rErG)�ndminrr�)�	enumerater�rLr�rN�aranger�r�r�r	rr�r�r��appendr�concatenater)r�r�r�r��ir��locss       rVr�z$IntervalIndex._get_indexer_pointwise�s���r�����'�F�A�s�
&��|�|�C�(���d�E�*��9�9�T�Z�Z����D�I�I�V�T�D��^�^�D�)��8�8�D��2�D��8�8�D�>�!�,�D�
�N�N�4� �)(�,�.�.��)��"�7�+�-@��-I�I�I���
&����q�!��x�x���~��$�
&����q�!��x�x���~��	
&�s�BC3�30E�%/E�Ec�R�|jxr|jjdkS)N�)r�r��	_na_countr�s rV�_index_as_uniquezIntervalIndex._index_as_uniques%���&�&�&�E�4�<�<�+A�+A�A�+E�ErXzKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniquec���|j�<|jdk(s-d}|dk(rt|��|dk(rt|�st|��t�|�||�S)NrGzClabel-based slicing with step!=1 is not supported for IntervalIndex�loc�getitem)r�r�r,�super�_convert_slice_indexer)r�r��kind�msg�	__class__s    �rVr
z$IntervalIndex._convert_slice_indexers\������ �C�H�H��M�X�C��u�}� ��o�%��y� �0��5�$�S�/�)��w�-�c�4�8�8rXc�F�|jjjdvS)NrF)rEr�rr�s rV�_should_fallback_to_positionalz,IntervalIndex._should_fallback_to_positional+s���z�z�!�!�&�&�$�.�.rXc�:�t||�j||�S�N)rJ�_maybe_cast_slice_bound)r�rUr�s   rVrz%IntervalIndex._maybe_cast_slice_bound3s���t�T�"�:�:�5�$�G�GrXc�j�t|t�syt|j|g�}t	|�S)NF)rLr%rrEr!)r�rE�common_subtypes   rV�_is_comparable_dtypez"IntervalIndex._is_comparable_dtype6s0���%��/��)�4�:�:�u�*=�>��"�>�2�2�2rXc�D�t|jjd��S�NF)r{)r-rxr�r�s rVr�zIntervalIndex.left>s���T�Z�Z�_�_�5�1�1rXc�D�t|jjd��Sr)r-rxr�r�s rVr�zIntervalIndex.rightBs���T�Z�Z�%�%�E�2�2rXc�D�t|jjd��Sr)r-rx�midr�s rVrzIntervalIndex.midFs���T�Z�Z�^�^�%�0�0rXc�D�t|jjd��Sr)r-rx�lengthr�s rVrzIntervalIndex.lengthJs���T�Z�Z�&�&�U�3�3rXc��|jjr(|jjr|j|�}np|jjrI|jjr3|j	�j�dkr|j|�}n|j
|�}|�|j�}|S)zL
        intersection specialized to the case with matching dtypes.
        rG)r�r�r��_intersection_uniquer�r��_intersection_non_unique�sort_values)r��other�sort�takens    rV�
_intersectionzIntervalIndex._intersectionQs���
�9�9���4�:�:�#7�#7��-�-�e�4�E�
�Z�Z�
!�
!�e�k�k�&;�&;��	�	����@Q�UV�@V��.�.�t�4�E��1�1�%�8�E��<��%�%�'�E��rXc�(�|jj|j�}|jj|j�}||k(|dk7z}|j|j	�d�}t|�}|j|�S)a'
        Used when the IntervalIndex does not have any common endpoint,
        no matter left or right.
        Return the intersection with another IntervalIndex.
        Parameters
        ----------
        other : IntervalIndex
        Returns
        -------
        IntervalIndex
        r�r)r�r�r��taker�r()r�r!�lindexer�rindexer�matchr�s      rVrz"IntervalIndex._intersection_uniqueesx���9�9�(�(����4���:�:�)�)�%�+�+�6���X�%�(�b�.�9���-�-��
�
��� 2�3����/���y�y��!�!rXc��tjt|�t��}|jrC|jr7tj
t|��|j
�d}d||<tt|j|j��}tt|j|j��D]\}}||vs�d||<�||S)a
        Used when the IntervalIndex does have some common endpoints,
        on either sides.
        Return the intersection with another IntervalIndex.

        Parameters
        ----------
        other : IntervalIndex

        Returns
        -------
        IntervalIndex
        r�rT)rN�zerosr�rwr�r�r�r��zipr�r�r�)r�r!r��
first_nan_loc�
other_tupsr�tups       rVrz&IntervalIndex._intersection_non_unique{s��� �x�x��D�	��.���<�<�E�M�M��I�I�c�$�i�0�����=�a�@�M�"&�D�����U�Z�Z����5�6�
���D�I�I�t�z�z� :�;�F�A�s��j� ���Q��<��D�z�rXc��td��)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects�r�r�s rV�_get_engine_targetz IntervalIndex._get_engine_target�s��"�
"�
�	
rXc��td��)Nz,IntervalIndex does not use libjoin fastpathsr1)r��results  rV�_from_join_targetzIntervalIndex._from_join_target�s��!�"P�Q�QrX)NNFNT)rs�IntervalClosedType | NonerE�Dtype | Noner{rwrB�Hashable | Noner|rw�returnr<)r�NFN)
rsr6rBr8r{rwrEr7r9r>)
rsr;rBr8r{rwrEr7r9r>)r9r)r�rr9rw)r�r�r9r>)r9r5)r9�str)F)r�rwr9�int�r9rw)r�)r�zLiteral['left', 'right'])r9zint | slice | np.ndarray)NNN)
r�r-r�z
str | Noner�z
int | Noner�z
Any | Noner9�npt.NDArray[np.intp])r�r-r9z1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])r�r>r9r=)r�r�rzLiteral['loc', 'getitem'])r�r:)rEr:r9rw)r9r-)r!r>r9r>)r9z
np.ndarray)9r}�
__module__�__qualname__�_typ�__annotations__�_can_hold_stringsr*�	_data_clsr��classmethodrr+�textwrap�dedentr�r]r�rr�r�r�r�r��propertyr�r-r��__doc__r�r�r�r�r�r�r�r�r.�_index_doc_kwargsr�r�r�r�_requires_unique_msgr
rrrr�r�rrr$rrr2r5�
__classcell__)r
s@rVr>r>�s����Z�D�
��"&�&������O�����
�����I�-1�"�� $�!%�,�*�,��	,�
�,��
,��,�
�,�,�
��m�,�$�#�H�O�O�:��
(������
�	
��.-4� $��"�
1�*�1��	1�
�1��
1�
�1�)��*1��
��m�,�$�#�H�O�O�:��
(������
�	
��0&-� $��"�
1�#�	
1�
�
1��

1��
1�
�
1�)��*
1��
��m�,�$�#�H�O�O�:��
(������
�	
��.&-� $��"�
/�#�
/��	
/�
�
/��
/�
�
/�)��*
/��=��=��2<��X��X�9�����
�e� � �(�(�)�V�*�V��2��2�����.�/+��/+�b)�2@�D<�:A�L"� � $�,��,��,��	,�
�,�
�
,�4� �!9�:�=N�N�O�J��J�	:�J�P�J�<
�J��J�	:�J�@�F��F�	V��9��/��/�H�3��2��2��3��3��1��1��4��4��("�,�>
�RrXc�n�tt|�t|t�t|t�|dug�S)zJ
    Helper for interval_range to check if start/end are valid types.
    N)�anyr rLrr)�endpoints rV�_is_valid_endpointrO�s:����h���x��+��x��+����		
��rXc��d�}d�}t|�xrt|�xs>||�xr||�xs*||�xr||�xstj||�S)zK
    Helper for interval_range to check type compat of start/end/freq.
    c�.�t|ttf�Sr)rLrr
��xs rV�<lambda>z%_is_type_compatible.<locals>.<lambda>����Z��I�z�+B�CrXc�.�t|ttf�Sr)rLrr
rRs rVrTz%_is_type_compatible.<locals>.<lambda>�rUrX)r �com�any_none)�a�b�is_ts_compat�is_td_compats    rV�_is_type_compatibler]�sc��D�L�C�L�	�1��	&�)�A�,�	���O�/��Q��	���O�/��Q��	��<�<��1��	rXc�l�t|�}t|�}|�|n|}|�&tj|||�rt|�rdnd}tj||||�dk7rtd��t
|�std|����t
|�std|����t|�}|�t|�s	t|�}tt||�t||�t||�g�std	��|�|dz
}t|�r�tj|||�rtj|||d
zz|�}nI|�t||z
|z�dz}n|�||dz
|zz
}n
|�||dz
|zz}tj |||�}td�tj"|||�D��rOt%|tj&d��}n/t)|t*�rt-||||�
�}nt/||||�
�}t0j3|||��S#t
$r}td|���|�d}~wwxYw)a
    Return a fixed frequency IntervalIndex.

    Parameters
    ----------
    start : numeric or datetime-like, default None
        Left bound for generating intervals.
    end : numeric or datetime-like, default None
        Right bound for generating intervals.
    periods : int, default None
        Number of periods to generate.
    freq : numeric, str, Timedelta, datetime.timedelta, or DateOffset, default None
        The length of each interval. Must be consistent with the type of start
        and end, e.g. 2 for numeric, or '5H' for datetime-like.  Default is 1
        for numeric and 'D' for datetime-like.
    name : str, default None
        Name of the resulting IntervalIndex.
    closed : {'left', 'right', 'both', 'neither'}, default 'right'
        Whether the intervals are closed on the left-side, right-side, both
        or neither.

    Returns
    -------
    IntervalIndex

    See Also
    --------
    IntervalIndex : An Index of intervals that are all closed on the same side.

    Notes
    -----
    Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
    exactly three must be specified. If ``freq`` is omitted, the resulting
    ``IntervalIndex`` will have ``periods`` linearly spaced elements between
    ``start`` and ``end``, inclusively.

    To learn more about datetime-like frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.

    Examples
    --------
    Numeric ``start`` and  ``end`` is supported.

    >>> pd.interval_range(start=0, end=5)
    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
                  dtype='interval[int64, right]')

    Additionally, datetime-like input is also supported.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   end=pd.Timestamp('2017-01-04'))
    IntervalIndex([(2017-01-01 00:00:00, 2017-01-02 00:00:00],
                   (2017-01-02 00:00:00, 2017-01-03 00:00:00],
                   (2017-01-03 00:00:00, 2017-01-04 00:00:00]],
                  dtype='interval[datetime64[ns], right]')

    The ``freq`` parameter specifies the frequency between the left and right.
    endpoints of the individual intervals within the ``IntervalIndex``.  For
    numeric ``start`` and ``end``, the frequency must also be numeric.

    >>> pd.interval_range(start=0, periods=4, freq=1.5)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
                  dtype='interval[float64, right]')

    Similarly, for datetime-like ``start`` and ``end``, the frequency must be
    convertible to a DateOffset.

    >>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
    ...                   periods=3, freq='MS')
    IntervalIndex([(2017-01-01 00:00:00, 2017-02-01 00:00:00],
                   (2017-02-01 00:00:00, 2017-03-01 00:00:00],
                   (2017-03-01 00:00:00, 2017-04-01 00:00:00]],
                  dtype='interval[datetime64[ns], right]')

    Specify ``start``, ``end``, and ``periods``; the frequency is generated
    automatically (linearly spaced).

    >>> pd.interval_range(start=0, end=6, periods=4)
    IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
              dtype='interval[float64, right]')

    The ``closed`` parameter specifies which endpoints of the individual
    intervals within the ``IntervalIndex`` are closed.

    >>> pd.interval_range(end=5, periods=4, closed='both')
    IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
                  dtype='interval[int64, both]')
    NrG�D�zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedz,start must be numeric or datetime-like, got z*end must be numeric or datetime-like, got z7freq must be numeric or convertible to DateOffset, got z+start, end, freq need to be type compatibleg�������?c3�2K�|]}t|����y�wr)r)�.0rSs  rV�	<genexpr>z!interval_range.<locals>.<genexpr>_s����E�&D��z�!�}�&D�s��int64)r��end�periods�freq)rBrs)rrWrXr �count_not_noner�rOr)r�allr]rR�all_not_nonerNr�r;�linspace�not_nonerrErLrr2r7r>r�)	r�rerfrgrBrsrNr�r�s	         rV�interval_rangerm�sZ��@
#�5�)�E�
 ��
%�C��)�u�s�H��|����W�e�S�9��h�'�q�S��
���%��g�t�4��9��
4�
�	
�
�e�$��G��w�O�P�P��c�"��E�c�U�K�L�L��w�'�G���	�$��	��T�?�D����s�+���t�,���T�*�	
���E�F�F����1���������E�3��-��Y�Y�u�c�T�C�Z�&8�$�?�F����s�U�{�t�3�4�q�8�����w��{�d�2�2�����w��{�d�2�2���[�[���W�5�F��E�c�l�l�5�#�t�&D�E�E�,������!��F��h�	�*��e��g�D�Q�F�$�5�c�7�QU�V�F��$�$�V�$�v�$�F�F��i�	��I�$��P���
��	�s�6H�	H3�H.�.H3r<)NNNNNr�)rBr8rsr;r9r>)hrH�
__future__r�operatorrrrE�typingrrr�numpyrN�pandas._libsr	�pandas._libs.intervalr
rr�pandas._libs.tslibsr
rrrr�
pandas.errorsr�pandas.util._decoratorsrr�pandas.util._exceptionsr�pandas.core.dtypes.castrrrrr�pandas.core.dtypes.commonrrrrrr r!r"r#�pandas.core.dtypes.dtypesr$r%�pandas.core.dtypes.missingr&�pandas.core.algorithmsr(�pandas.core.arrays.datetimeliker)�pandas.core.arrays.intervalr*r+�pandas.core.common�core�commonrW�pandas.core.indexersr,�pandas.core.indexes.base�indexes�base�ibaser-r.r/r0�pandas.core.indexes.datetimesr1r2�pandas.core.indexes.extensionr3r4�pandas.core.indexes.multir5�pandas.core.indexes.timedeltasr6r7�collections.abcr8�pandas._typingr9r:r;r<r=�dictrI�updaterFrWrZr`r>rOr]rmr\rXrV�<module>r�s�� �"���������
��,��6���
�
�
��=�)�<��!� �:�(�(�����1��
�(�����0�0�1����� �#�<�����

�
�	
��U�"U�" �
��'�"� �S�!�&�)�6��#�H�O�O�
�
�
���:��k�*�M��E��	����.��9�=�PT�U�YR�N�YR�V��F�;�XYR�|�����	
� �!(�
kG�
�kG�
�
kG��kGrX

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