o
    5c(                     @  sb  d dl mZ d dlZd dl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 d d	lmZmZmZmZmZ d d
l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#m$Z$ d dl%m&Z& d dl'm(Z( d dl)m*Z* e+dZ,g dZ-	d4d5ddZ.d6d d!Z/			d7d8d#d$Z0d9d&d'Z1d:d;d)d*Z2d+d, Z3d<d-d.Z4d=d2d3Z5dS )>    )annotationsN)cast)NaTlib)InvalidIndexErrorfind_common_type)is_dtype_equal)	safe_sort)Index
_new_Indexensure_indexensure_index_from_sequencesget_unanimous_names)CategoricalIndex)DatetimeIndex)IntervalIndex)
MultiIndex)Float64Index
Int64IndexNumericIndexUInt64Index)PeriodIndex)
RangeIndex)TimedeltaIndexzSorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.

To accept the future behavior, pass 'sort=False'.

To retain the current behavior and silence the warning, pass 'sort=True'.
)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   get_objs_combined_axisunion_indexesr   all_indexes_samedefault_indexsafe_sort_indexFT	intersectboolsortcopyreturnr   c                   s"    fdd| D }t ||||dS )a  
    Extract combined index: return intersection or union (depending on the
    value of "intersect") of indexes on given axis, or None if all objects
    lack indexes (e.g. they are numpy arrays).

    Parameters
    ----------
    objs : list
        Series or DataFrame objects, may be mix of the two.
    intersect : bool, default False
        If True, calculate the intersection between indexes. Otherwise,
        calculate the union.
    axis : {0 or 'index', 1 or 'outer'}, default 0
        The axis to extract indexes from.
    sort : bool, default True
        Whether the result index should come out sorted or not.
    copy : bool, default False
        If True, return a copy of the combined index.

    Returns
    -------
    Index
    c                   s   g | ]}|  qS  )	_get_axis).0objaxisr%   M/var/www/html/gps/gps/lib/python3.10/site-packages/pandas/core/indexes/api.py
<listcomp>h       z*get_objs_combined_axis.<locals>.<listcomp>)r    r"   r#   )_get_combined_index)objsr    r*   r"   r#   	obs_idxesr%   r)   r+   r   N   s   r   r/   list[Index]c                 C  s<   t  }g }| D ]}t||vr|t| || q|S )z^
    Return a list with distinct elements of "objs" (different ids).
    Preserves order.
    )setidaddappend)r/   idsresr(   r%   r%   r+   _get_distinct_objsl   s   
r8   indexesc                 C  s   t | } t| dkrtg }n*t| dkr| d }n|r/| d }| dd D ]}||}q&n
t| dd}t|}|r?t|}|rE| }|S )a  
    Return the union or intersection of indexes.

    Parameters
    ----------
    indexes : list of Index or list objects
        When intersect=True, do not accept list of lists.
    intersect : bool, default False
        If True, calculate the intersection between indexes. Otherwise,
        calculate the union.
    sort : bool, default False
        Whether the result index should come out sorted or not.
    copy : bool, default False
        If True, return a copy of the combined index.

    Returns
    -------
    Index
    r      NFr"   )r8   lenr   intersectionr   r   r   r#   )r9   r    r"   r#   indexotherr%   r%   r+   r.   z   s"   

r.   r>   c                 C  sz   | j r| S zt| }W n
 ty   Y | S w t|tr|S ttj|}t| tr2tj|| j	d} | S t
|| j| jd} | S )z
    Returns the sorted index

    We keep the dtypes and the name attributes.

    Parameters
    ----------
    index : an Index

    Returns
    -------
    Index
    )names)namedtype)is_monotonic_increasingr
   	TypeError
isinstancer   r   npndarrayfrom_tuplesr@   r   rA   rB   )r>   array_sortedr%   r%   r+   r      s    

r   bool | Nonec                   s  t dkr
tdt dkr!d }t|trtt|}|S t\}dfdd}fdd	}|d
krd }| dd D }dd |D }t |dt |fvrZtdt |t kr{dt fddD svdd D d }nt |dkrddd D d }dd D ]}|j	|rdndd}q|S |dkr|}	d tfdddd D s||	t
 d }
|
jkrԈ|
S |}	||	S )a)  
    Return the union of indexes.

    The behavior of sort and names is not consistent.

    Parameters
    ----------
    indexes : list of Index or list objects
    sort : bool, default True
        Whether the result index should come out sorted or not.

    Returns
    -------
    Index
    r   z#Must have at least 1 Index to unionr:   r$   r   c                   s,   dd  t tj fdd| D d|dS )a3  
        Convert indexes to lists and concatenate them, removing duplicates.

        The final dtype is inferred.

        Parameters
        ----------
        inds : list of Index or list objects
        dtype : dtype to set for the resulting Index

        Returns
        -------
        Index
        c                 S  s   t | tr	|  } | S N)rE   r   tolist)ir%   r%   r+   conv   s   
z4union_indexes.<locals>._unique_indices.<locals>.convc                   s   g | ]} |qS r%   r%   )r'   rM   rN   r%   r+   r,          z:union_indexes.<locals>._unique_indices.<locals>.<listcomp>r;   )rB   )r   r   fast_unique_multiple_list)indsrB   r;   rO   r+   _unique_indices   s
   z&union_indexes.<locals>._unique_indicesc                   s&   dd  D }|rt |}|S d}|S )a  
        Finds a common type for the indexes to pass through to resulting index.

        Parameters
        ----------
        inds: list of Index or list objects

        Returns
        -------
        The common type or None if no indexes were given
        c                 S  s   g | ]
}t |tr|jqS r%   )rE   r   rB   )r'   idxr%   r%   r+   r,     s    zCunion_indexes.<locals>._find_common_index_dtype.<locals>.<listcomp>Nr   )rR   dtypesrB   )r9   r%   r+   _find_common_index_dtype   s   z/union_indexes.<locals>._find_common_index_dtypespecialc                 S  s   g | ]	}t |tr|qS r%   )rE   r   r'   xr%   r%   r+   r,         z!union_indexes.<locals>.<listcomp>c                 S  s   g | ]	}|j d ur|qS rK   )tzrX   r%   r%   r+   r,     rZ   z0Cannot join tz-naive with tz-aware DatetimeIndexTc                 3  s    | ]
}t |j jV  qd S rK   )r	   rB   rX   firstr%   r+   	<genexpr>#  s    z union_indexes.<locals>.<genexpr>c                 S  s   g | ]}| d qS )UTC)
tz_convertrX   r%   r%   r+   r,   '  r-   Fc                 S  s   g | ]	}|j td dqS )F)r#   )astypeobjectrX   r%   r%   r+   r,   2  rZ   Nr;   arrayc                 3      | ]}  |V  qd S rK   equals)r'   r?   )r>   r%   r+   r^   <      )r$   r   )r<   AssertionErrorrE   listr   sorted_sanitize_and_checkrD   allunionr   rA   rename)r9   r"   resultkindrS   rV   dtisdti_tzsr?   rB   rA   r%   )r]   r>   r9   r"   r+   r      sP   





r   c                 C  sl   t dd | D }t |v r$t|dkr dd | D } |t  n| dfS t|dks.t|vr2| dfS | dfS )	aN  
    Verify the type of indexes and convert lists to Index.

    Cases:

    - [list, list, ...]: Return ([list, list, ...], 'list')
    - [list, Index, ...]: Return _sanitize_and_check([Index, Index, ...])
        Lists are sorted and converted to Index.
    - [Index, Index, ...]: Return ([Index, Index, ...], TYPE)
        TYPE = 'special' if at least one special type, 'array' otherwise.

    Parameters
    ----------
    indexes : list of Index or list objects

    Returns
    -------
    sanitized_indexes : list of Index or list objects
    type : {'list', 'array', 'special'}
    c                 S  s   h | ]}t |qS r%   )typer'   r>   r%   r%   r+   	<setcomp>]  rP   z&_sanitize_and_check.<locals>.<setcomp>r:   c                 S  s&   g | ]}t |tstt|n|qS r%   )rE   r   ri   rX   r%   r%   r+   r,   a  s    z'_sanitize_and_check.<locals>.<listcomp>ri   rW   rc   )ri   r<   remover   )r9   kindsr%   r%   r+   rk   H  s   rk   c                   s&   t | }t| t fdd|D S )z
    Determine if all indexes contain the same elements.

    Parameters
    ----------
    indexes : iterable of Index objects

    Returns
    -------
    bool
        True if all indexes contain the same elements, False otherwise.
    c                 3  rd   rK   re   rt   r\   r%   r+   r^   }  rg   z#all_indexes_same.<locals>.<genexpr>)iternextrl   )r9   itrr%   r\   r+   r   n  s   r   nintr   c                 C  s   t d| }tj|d dS )Nr   )rA   )ranger   _simple_new)r{   rngr%   r%   r+   r     s   
r   )Fr   TF)r    r!   r"   r!   r#   r!   r$   r   )r/   r1   r$   r1   )FFF)
r9   r1   r    r!   r"   r!   r#   r!   r$   r   )r>   r   r$   r   )T)r"   rJ   r$   r   )r$   r!   )r{   r|   r$   r   )6
__future__r   textwraptypingr   numpyrF   pandas._libsr   r   pandas.errorsr   pandas.core.dtypes.castr   pandas.core.dtypes.commonr	   pandas.core.algorithmsr
   pandas.core.indexes.baser   r   r   r   r   pandas.core.indexes.categoryr   pandas.core.indexes.datetimesr   pandas.core.indexes.intervalr   pandas.core.indexes.multir   pandas.core.indexes.numericr   r   r   r   pandas.core.indexes.periodr   pandas.core.indexes.ranger   pandas.core.indexes.timedeltasr   dedent	_sort_msg__all__r   r8   r.   r   r   rk   r   r   r%   r%   r%   r+   <module>   sD    

0"|
&