o
    �¨Êh.•  ã                
   @  sÀ  d Z ddlmZ ddlmZmZ ddlZddlmZm	Z	m
Z
 ddl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 dd	lmZ dd
lmZmZ ddlmZ ddl m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z; ddl<m=  m>Z? ddl@mAZA ddlBm=  mC  mDZE ddlBmFZFmGZGmHZHmIZI ddlJmKZKmLZL ddlMmNZNmOZO ddlPmQZQ ddlRmSZSmTZT erõddlUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\ e]eEj^ƒZ^e^ _ddde `d¡dœ¡ dd „ Zad!d"„ Zbd#d$„ Zcee;d% dd&e^d' d(d)e `d*¡d+œ ƒeOd,d-ge:d.d/�eOg d0¢e:ƒeOd1d2ge:d.d3�G d4d„ deNƒƒƒƒƒZdd@d7d8„Zed@d9d:„Zf						;dAdBd>d?„ZgdS )Cz 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                 C  sŒ   t | dt| ƒƒ}t| ttfƒrd}t|ƒ}t |d¡s t|tƒr(| t	 
dd¡ S t|ƒr0| d S t|ƒr;t	 | t	j¡S tdtt| ƒƒ› �ƒ‚©NÚdtypezdatetime64[ns]ÚmMé   Únsz%cannot determine next label for type ©ÚgetattrÚtypeÚ
isinstancer   r   r"   r   Úis_np_dtyper#   ÚnpÚtimedelta64r   r   Ú	nextafterÚinfÚ	TypeErrorÚrepr©ÚlabelrC   © rT   úN/var/www/html/env/lib/python3.10/site-packages/pandas/core/indexes/interval.pyÚ_get_next_labelu   s   rV   c                 C  sŽ   t | dt| ƒƒ}t| ttfƒrd}t|ƒ}t |d¡s t|tƒr(| t	 
dd¡ S t|ƒr0| d S t|ƒr<t	 | t	j ¡S tdtt| ƒƒ› �ƒ‚rB   rG   rR   rT   rT   rU   Ú_get_prev_label†   s   rW   c                 C  s   | j di |¤ŽS )zv
    This is called upon unpickling, rather than the default which doesn't have
    arguments and breaks __new__.
    NrT   )Úfrom_arrays)ÚclsÚdrT   rT   rU   Ú_new_IntervalIndex—   s   r[   Úclassz>Immutable index of intervals that are closed on the same side.rA   zis_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>   ÚsummaryrA   Ú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                      sÀ  e Zd ZU dZded< ded< ded< ded< ded< ded	< d
ed< d
ed< dZeZ					dˆd‰dd„Ze	e
ed d e d¡e d¡dœ ƒ				dŠd‹d d!„ƒƒZe	e
ed" d e d¡e d#¡dœ ƒ				dŠdŒd$d%„ƒƒZe	e
ed& d e d¡e d'¡dœ ƒ				dŠdŒd(d)„ƒƒZed�d+d,„ƒZdŽd/d0„Zd�d3d4„Zed�d6d7„ƒZd8d9„ Zed‘d;d<„ƒZe
ejjƒd’d“d?d@„ƒZed”dAdB„ƒZed”dCdD„ƒZed”dEdF„ƒZd”dGdH„ZdIdJ„ Z d•d–dNdO„Z!d—dQdR„Z"			d˜d™d\d]„Z#e
e$d^ e% ƒdšd`da„ƒZ&d›dbdc„Z'dšddde„Z(ed”dfdg„ƒZ)dhZ*dœ‡ fdkdl„Z+ed”dmdn„ƒZ,d�dodp„Z-dždrds„Z.edŸdtdu„ƒZ/edŸdvdw„ƒZ0edŸdxdy„ƒZ1edŸdzd{„ƒZ2d|d}„ Z3d dd€„Z4d d�d‚„Z5d¡d„d…„Z6d†d‡„ Z7‡  Z8S )¢r=   Úintervalindexr:   rn   Úboolrm   rh   ri   rj   rk   r)   Ú_dataÚ_valuesFNTúIntervalClosedType | NonerC   úDtype | NoneÚcopyrA   úHashable | NoneÚverify_integrityÚreturnr;   c                 C  sV   t ||| ƒ}td| jƒ� t|||||d�}W d   ƒ n1 s w   Y  |  ||¡S )Nr)   )rn   rv   rC   rx   )r/   r   Ú__name__r)   Ú_simple_new)rY   Údatarn   rC   rv   rA   rx   ÚarrayrT   rT   rU   Ú__new__Þ   s   	ûÿ	zIntervalIndex.__new__Ú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>   rA   ra   Úrightc                 C  óL   t d| jƒ� tj||||d�}W d   ƒ n1 sw   Y  | j||d�S ©Nr)   )rn   rv   rC   ©rA   )r   rz   r)   r   r{   )rY   Úbreaksrn   rA   rv   rC   r}   rT   rT   rU   r   ô   s   ÿÿzIntervalIndex.from_breaksrX   zÏ        Examples
        --------
        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])
        IntervalIndex([(0, 1], (1, 2], (2, 3]],
                      dtype='interval[int64, right]')
        c                 C  sN   t d| jƒ� tj|||||d�}W d   ƒ n1 sw   Y  | j||d�S )Nr)   )rv   rC   rƒ   )r   rz   r)   rX   r{   )rY   Úleftr€   rn   rA   rv   rC   r}   rT   rT   rU   rX     s   
ÿÿzIntervalIndex.from_arraysÚfrom_tupleszÄ        Examples
        --------
        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])
        IntervalIndex([(0, 1], (1, 2]],
                       dtype='interval[int64, right]')
        c                 C  r�   r‚   )r   rz   r)   r†   r{   )rY   r|   rn   rA   rv   rC   ÚarrrT   rT   rU   r†   ;  s   ÿzIntervalIndex.from_tuplesr   c                 C  s8   |   | j¡}t|ƒ}|   | j¡}t|ƒ}t||| jd�S )N©rn   )Ú_maybe_convert_i8r…   r   r€   r   rn   )Úselfr…   r€   rT   rT   rU   Ú_engine_  s
   zIntervalIndex._engineÚkeyr   c                 C  sN   t |ƒ t|tƒst|| jƒr| jS dS z|  |¡ W dS  ty&   Y dS w )zÏ
        return a boolean if this key is IN the index
        We *only* accept an Interval

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

        Returns
        -------
        bool
        FT)ÚhashrJ   r	   r%   rC   ÚhasnansÚget_locÚKeyError)rŠ   rŒ   rT   rT   rU   Ú__contains__h  s   

ÿzIntervalIndex.__contains__ÚslobjÚslicec                 C  s   | j | }t| ƒj|| jd�S )zH
        Fastpath for __getitem__ when we know we have a slice.
        rƒ   )rr   rI   r{   Ú_name)rŠ   r’   ÚresrT   rT   rU   Ú_getitem_slice�  s   
zIntervalIndex._getitem_slicer4   c                 C  s   t j| j| jgddgd�S )Nr…   r€   )Únames)r4   rX   r…   r€   ©rŠ   rT   rT   rU   Ú_multiindexˆ  s   zIntervalIndex._multiindexc                 C  s(   | j | j| j| jdœ}tt| ƒ|fd fS )N)r…   r€   rn   rA   )r…   r€   rn   rA   r[   rI   )rŠ   rZ   rT   rT   rU   Ú
__reduce__Œ  s   üzIntervalIndex.__reduce__Ústrc                 C  s   dS )z4Return a string of the type inferred from the valuesÚintervalrT   r˜   rT   rT   rU   Úinferred_type•  s   zIntervalIndex.inferred_typeÚdeepÚintc                 C  s   | j j|d�| jj|d� S )N)rž   )r…   Úmemory_usager€   )rŠ   rž   rT   rT   rU   r    ›  s   zIntervalIndex.memory_usagec                 C  s   | ddd… j S )z€
        Return True if the IntervalIndex is monotonic decreasing (only equal or
        decreasing values), else False
        Néÿÿÿÿ)Úis_monotonic_increasingr˜   rT   rT   rU   Úis_monotonic_decreasing£  s   z%IntervalIndex.is_monotonic_decreasingc                 C  s‚   | j }| j}|  ¡  ¡ dkrdS |js|jrdS tƒ }t |jdd�¡d }|D ]}|| || f}||v r9 dS | 	|¡ q(dS )zX
        Return True if the IntervalIndex contains unique elements, else False.
        rE   FT)Úkeepr   )
r…   r€   ÚisnaÚsumÚ	is_uniqueÚsetrL   ÚwhereÚ
duplicatedÚadd)rŠ   r…   r€   Ú
seen_pairsÚ	check_idxÚidxÚpairrT   rT   rU   r§   «  s   zIntervalIndex.is_uniquec                 C  s   | j jS )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˜   rT   rT   rU   r°   Ã  s   0zIntervalIndex.is_overlappingc                 C  sB   t |ddƒ}t|tƒst|tƒr|  |j¡S tttt	f}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
        rC   N)
rH   rJ   r$   r	   Ú_needs_i8_conversionr…   r   r   r0   r5   )rŠ   rŒ   Ú	key_dtypeÚi8_typesrT   rT   rU   r±   õ  s
   
z"IntervalIndex._needs_i8_conversionc           	      C  s$  t |ƒrt|ƒ}t|ƒ}|  |¡s|S t|ƒ}t|ddƒ}t|tƒs't|tƒrB|  	|j
¡}|  	|j¡}|r7tntj}|||| jd�S |rkt|ƒ\}}t|tƒrS|j}n+t|tƒr\|j}n"t|tjtjfƒrj| d¡}n|jt|jƒ}}|jr~| |j ¡}| jj}||kr�t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.
        rC   Nrˆ   Úi8z)Cannot index an IntervalIndex of subtype z with values of dtype ) r   r.   r   r±   r!   rH   rJ   r$   r	   r‰   r…   r€   r=   rX   rn   r   r   Úordinalr   Ú_valuerL   Ú
datetime64rM   ÚviewrC   r,   Úasi8rŽ   r©   Ú_isnanÚsubtypeÚ
ValueError)	rŠ   rŒ   Úscalarr²   r…   r€   ÚconstructorÚkey_i8r»   rT   rT   rU   r‰     sD   
ÿ


€ÿÿzIntervalIndex._maybe_convert_i8r…   ÚsideúLiteral['left', 'right']c                 C  sz   | j stdƒ‚t|ttfƒrtdƒ‚|dkr| jjs"|dkr-| jjs-| j}| j	r,t
|ƒ}n
| j}| jr7t|ƒ}| ||¡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€   )rm   r�   rJ   r
   r=   ÚNotImplementedErrorr…   r¢   r€   rk   rV   rj   rW   Ú_searchsorted_monotonic)rŠ   rS   rÀ   Úsub_idxrT   rT   rU   rÃ   P  s    ÿ€z%IntervalIndex._searchsorted_monotonicúint | slice | np.ndarrayc              
   C  s  |   |¡ t|tƒr!| j|jkrt|ƒ‚| j|jk| j|jk@ }n9t|| jƒr,|  	¡ }n.| j
r1tnt}| jr8tnt}z|| j|ƒ||| jƒ@ }W n tyY } zt|ƒ|‚d}~ww | ¡ }|dkrft|ƒ‚|dkrn| ¡ S t | d¡¡}t|tƒrŠ|jdu rŠt|jt| ƒ|jƒ}|S )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
        Nr   rE   Úu1)Ú_check_indexing_errorrJ   r	   rn   r�   r…   r€   r%   rC   r¥   rh   r   r   ri   rP   r¦   Úargmaxr   Úmaybe_booleans_to_slicer¸   r“   ÚstopÚstartÚlenÚstep)rŠ   rŒ   ÚmaskÚop_leftÚop_rightÚerrÚmatchesr•   rT   rT   rU   r�   m  s0   
%


€þzIntervalIndex.get_locÚtargetr,   Úmethodú
str | NoneÚlimitú
int | NoneÚ	toleranceú
Any | Noneúnpt.NDArray[np.intp]c                 C  sT   t |tƒr|  |¡}t
|ƒS t|jƒs#|  |¡}| j |j¡}t
|ƒS |  	|¡d S )Nr   )rJ   r=   Ú_get_indexer_unique_sidesr    rC   r‰   r‹   Úget_indexerÚvaluesÚ_get_indexer_pointwiser   )rŠ   rÓ   rÔ   rÖ   rØ   ÚindexerrT   rT   rU   Ú_get_indexer°  s   


ö
þzIntervalIndex._get_indexerÚget_indexer_non_uniqueú1tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]c                 C  s¶   t |ƒ}|  |¡s|  |¡s| j|d dd�S t|tƒr6| jjr1| jjr1|  	|¡}|dk 
¡ d }n"|  |¡S t|jƒs@|  |¡sE|  |¡S |  |¡}| j |j¡\}}t|ƒt|ƒfS )NFr&   r¡   r   )r.   Ú_should_compareÚ_should_partial_indexÚ_get_indexer_non_comparablerJ   r=   r…   r§   r€   rÛ   ÚnonzerorÞ   r    rC   r‰   r‹   rá   rÝ   r   )rŠ   rÓ   rß   ÚmissingrT   rT   rU   rá   Ê  s   




z$IntervalIndex.get_indexer_non_uniquec                 C  s2   | j  |j ¡}| j |j¡}t ||k|d¡}|S )zZ
        _get_indexer specialized to the case where both of our sides are unique.
        r¡   )r…   rÜ   r€   rL   r©   )rŠ   rÓ   Úleft_indexerÚright_indexerrß   rT   rT   rU   rÛ   é  s   z'IntervalIndex._get_indexer_unique_sidesc              	   C  sê   g g }}t |ƒD ]^\}}z-|  |¡}t|tƒr%tj|j|j|jdd�}nt	 
|¡r2tj|dd�}nt |¡d }W n' tyN   | |¡ t dg¡}Y n tya   | |¡ t dg¡}Y nw | |¡ q	t |¡}t|ƒt|ƒfS )zV
        pointwise implementation for get_indexer and get_indexer_non_unique.
        Úintp©rC   rE   )Úndminr   r¡   )Ú	enumerater�   rJ   r“   rL   ÚarangerË   rÊ   rÍ   r   r   r}   r©   r�   Úappendr   Úconcatenater   )rŠ   rÓ   rß   rç   ÚirŒ   ÚlocsrT   rT   rU   rÞ   õ  s(   



€

ü
z$IntervalIndex._get_indexer_pointwisec                 C  s   | j  o	| jjdk S )Né   )r°   r‹   Ú	_na_countr˜   rT   rT   rU   Ú_index_as_unique  s   zIntervalIndex._index_as_uniquezKcannot handle overlapping indices; use IntervalIndex.get_indexer_non_uniqueÚkindúLiteral['loc', 'getitem']c                   sN   |j d u s |j dks d}|dkrt|ƒ‚|dkr t|ƒs t|ƒ‚tƒ  ||¡S )NrE   zClabel-based slicing with step!=1 is not supported for IntervalIndexÚlocÚgetitem)rÍ   r¼   r+   ÚsuperÚ_convert_slice_indexer)rŠ   rŒ   rö   Úmsg©Ú	__class__rT   rU   rû     s   z$IntervalIndex._convert_slice_indexerc                 C  s   | j jjdv S )NrD   )rC   r»   rö   r˜   rT   rT   rU   Ú_should_fallback_to_positional+  s   z,IntervalIndex._should_fallback_to_positionalc                 C  s   t | |ƒ ||¡S ©N)rH   Ú_maybe_cast_slice_bound)rŠ   rS   rÀ   rT   rT   rU   r  3  s   z%IntervalIndex._maybe_cast_slice_boundr9   c                 C  s&   t |tƒsdS t| j|gƒ}t|ƒ S )NF)rJ   r$   r   rC   r    )rŠ   rC   Úcommon_subtyperT   rT   rU   Ú_is_comparable_dtype6  s   

z"IntervalIndex._is_comparable_dtypec                 C  ó   t | jjdd�S ©NF)rv   )r,   rr   r…   r˜   rT   rT   rU   r…   >  ó   zIntervalIndex.leftc                 C  r  r  )r,   rr   r€   r˜   rT   rT   rU   r€   B  r  zIntervalIndex.rightc                 C  r  r  )r,   rr   Úmidr˜   rT   rT   rU   r  F  r  zIntervalIndex.midc                 C  r  r  )r,   rr   Úlengthr˜   rT   rT   rU   r  J  r  zIntervalIndex.lengthc                 C  sf   | j jr| jjr|  |¡}n|j jr$|jjr$|  ¡  ¡ dkr$| | ¡}n|  |¡}|du r1| ¡ }|S )zL
        intersection specialized to the case with matching dtypes.
        rE   N)r…   r§   r€   Ú_intersection_uniquer¥   r¦   Ú_intersection_non_uniqueÚsort_values)rŠ   ÚotherÚsortÚtakenrT   rT   rU   Ú_intersectionQ  s    
zIntervalIndex._intersectionr  c                 C  sP   | j  |j ¡}| j |j¡}||k|dk@ }| | ¡ d ¡}t|ƒ}|  |¡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ß   rT   rT   rU   r	  e  s   
z"IntervalIndex._intersection_uniquec                 C  s†   t jt| ƒtd�}| jr |jr t  t| ƒ¡|  ¡  d }d||< tt|j	|j
ƒƒ}tt| j	| j
ƒƒD ]\}}||v r>d||< q2| | 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ë   r   T)rL   ÚzerosrÌ   rq   rŽ   rî   r¥   r¨   Úzipr…   r€   rí   )rŠ   r  rÎ   Úfirst_nan_locÚ
other_tupsrñ   ÚtuprT   rT   rU   r
  {  s   €z&IntervalIndex._intersection_non_uniqueú
np.ndarrayc                 C  ó   t dƒ‚)NzRIntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects©rÂ   r˜   rT   rT   rU   Ú_get_engine_targetš  s   ÿz IntervalIndex._get_engine_targetc                 C  r  )Nz,IntervalIndex does not use libjoin fastpathsr  )rŠ   ÚresultrT   rT   rU   Ú_from_join_target£  s   zIntervalIndex._from_join_target)NNFNT)rn   rt   rC   ru   rv   rq   rA   rw   rx   rq   ry   r;   )r€   NFN)
rn   rt   rA   rw   rv   rq   rC   ru   ry   r=   )
rn   r:   rA   rw   rv   rq   rC   ru   ry   r=   )ry   r   )rŒ   r   ry   rq   )r’   r“   ry   r=   )ry   r4   )ry   r›   )F)rž   rq   ry   rŸ   ©ry   rq   )r…   )rÀ   rÁ   )ry   rÅ   )NNN)
rÓ   r,   rÔ   rÕ   rÖ   r×   rØ   rÙ   ry   rÚ   )rÓ   r,   ry   râ   )rÓ   r=   ry   rÚ   )rŒ   r“   rö   r÷   )rÀ   r›   )rC   r9   ry   rq   )ry   r,   )r  r=   ry   r=   )ry   r  )9rz   Ú
__module__Ú__qualname__Ú_typÚ__annotations__Ú_can_hold_stringsr)   Ú	_data_clsr~   Úclassmethodr   r*   ÚtextwrapÚdedentr   rX   r†   r   r‹   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û   rÿ   r  r  r…   r€   r  r  r  r	  r
  r  r  Ú__classcell__rT   rT   rý   rU   r=   Ÿ   sö   
 -ùÿÿùÿÿúÿÿùÿÿùÿÿùÿÿú

	

1B
Fû

 ÿ




	ry   rq   c                 C  s$   t t| ƒt| tƒt| tƒ| du gƒS )zJ
    Helper for interval_range to check if start/end are valid types.
    N)Úanyr   rJ   r   r   )ÚendpointrT   rT   rU   Ú_is_valid_endpoint©  s   üÿr0  c                 C  sL   dd„ }dd„ }t | ƒrt |ƒp%|| ƒo||ƒp%|| ƒo||ƒp%t | |¡S )zK
    Helper for interval_range to check type compat of start/end/freq.
    c                 S  ó   t | ttfƒS r   )rJ   r   r   ©ÚxrT   rT   rU   Ú<lambda>»  ó    z%_is_type_compatible.<locals>.<lambda>c                 S  r1  r   )rJ   r   r   r2  rT   rT   rU   r4  ¼  r5  )r   ÚcomÚany_none)ÚaÚbÚis_ts_compatÚis_td_compatrT   rT   rU   Ú_is_type_compatible·  s   ÿþ
ür<  r€   rw   r:   c           	   
   C  s
  t | ƒ} t |ƒ}| dur| n|}|du r#t || |¡r#t|ƒr!dnd}t | |||¡dkr1tdƒ‚t| ƒs<td| › �ƒ‚t|ƒsGtd|› �ƒ‚t|ƒ}|durnt|ƒsnzt|ƒ}W n tym } ztd|› �ƒ|‚d}~ww t	t
| |ƒt
| |ƒt
||ƒgƒs‚td	ƒ‚|durŠ|d7 }t|ƒrçt | ||¡r¡t | ||d
  |¡}n/|du r°t||  | ƒd }n| du r½||d |  } n|du rÉ| |d |  }t | ||¡}t	dd„ t | ||¡D ƒƒræt|t d¡ƒ}nt|tƒrõt| |||d�}nt| |||d�}tj|||d�S )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]')
    NrE   Ú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š™™™™™¹?c                 s  s   � | ]}t |ƒV  qd S r   )r   )Ú.0r3  rT   rT   rU   Ú	<genexpr>_  s   € z!interval_range.<locals>.<genexpr>Úint64)rË   ÚendÚperiodsÚfreq)rA   rn   )r   r6  r7  r   Úcount_not_noner¼   r0  r(   r   Úallr<  rP   Úall_not_nonerL   rî   rŸ   ÚlinspaceÚnot_noner   rC   rJ   r   r1   r6   r=   r   )	rË   rB  rC  rD  rA   rn   r/  rÑ   r„   rT   rT   rU   Úinterval_rangeÅ  sl   `ÿÿþ€ÿýÿþ€
rJ  r  )NNNNNr€   )rA   rw   rn   r:   ry   r=   )hr*  Ú
__future__r   Úoperatorr   r   r'  Útypingr   r   r   ÚnumpyrL   Úpandas._libsr   Úpandas._libs.intervalr	   r
   r   Úpandas._libs.tslibsr   r   r   r   r   Úpandas.errorsr   Úpandas.util._decoratorsr   r   Úpandas.util._exceptionsr   Úpandas.core.dtypes.castr   r   r   r   r   Úpandas.core.dtypes.commonr   r   r   r   r   r   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Úcommonr6  Úpandas.core.indexersr+   Úpandas.core.indexes.baseÚindexesÚbaseÚibaser,   r-   r.   r/   Úpandas.core.indexes.datetimesr0   r1   Úpandas.core.indexes.extensionr2   r3   Úpandas.core.indexes.multir4   Úpandas.core.indexes.timedeltasr5   r6   Úcollections.abcr7   Úpandas._typingr8   r9   r:   r;   r<   Údictr+  Úupdater(  rV   rW   r[   r=   r0  r<  rJ  rT   rT   rT   rU   Ú<module>   sš    ,
ÿüÿÿúÿÿ
õ     
c
ú