
    d                    f   d dl mZ d dlZd dl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 d dlZd dlZd dlmZmZmZ d dlmZmZmZ d dlmZmZm Z m!Z!m"Z" erd d	l#m$Z$m%Z% d d
l&m'Z' e(edf         Z) G d d          Z*dYdZ+dZdZ,d Z-d[dZ.d Z/d Z0d\d]dZ1d^dZ2d_dZ3 edd !          Z4 G d" d e*          Z5d`dad(Z6dYd)Z7 G d* d+e5          Z8	 d\dbd0Z9 ed1e*ej*                  Z: G d2 d3ej;        j	        ee:                   Z<dcd8Z=	 d\ddd?Z>dedBZ?dfdIZ@dgdKZAdhdNZBdidRZC	 djdkdXZDdS )l    )annotationsN)defaultdict)HashableIterableIteratorMappingSequence)TYPE_CHECKINGAnyGenericTypeVarcast)
formattingnputilsutils)IndexSelResultPandasIndexingAdapterPandasMultiIndexingAdapter)Frozenemit_user_level_warningget_valid_numpy_dtypeis_dict_like	is_scalar)ErrorOptionsT_IndexVariabler   c                      e Zd ZdZed@d            Ze	 dAdBd            ZedCd            ZdDdZ	 dAdEdZ	dFdZ
dGdZdHd"ZdIdJd(ZdKd*Zd+ ZdLd.ZdMd2ZdNd3ZdAdOd6ZdPdQd:Z	 dRdSd;ZdTd>Zd? ZdS )UIndexz|Base class inherited by all xarray-compatible indexes.

    Do not use this class directly for creating index objects.

    	variablesMapping[Any, Variable]optionsMapping[str, Any]returnc                   t                      NNotImplementedError)clsr    r"   s      3lib/python3.11/site-packages/xarray/core/indexes.pyfrom_variableszIndex.from_variables(        "###    Nr)   type[T_Index]indexesSequence[T_Index]dimr   	positionsIterable[Iterable[int]] | Noner   c                    t                      r&   r'   )r)   r/   r1   r2   s       r*   concatzIndex.concat1   r,   r-   c                &    t          | d          )Nz< cannot be used for creating an index of stacked coordinatesr'   )r)   r    r1   s      r*   stackzIndex.stack:   s     !RRR
 
 	
r-   +tuple[dict[Hashable, Index], pd.MultiIndex]c                    t                      r&   r'   selfs    r*   unstackzIndex.unstack@       !###r-   Mapping[Any, Variable] | None	IndexVarsc                "    |t          di |S i S )N )dict)r;   r    s     r*   create_variableszIndex.create_variablesC   s#      $$)$$$Ir-   pd.Indexc                &    t          | d          )zCast this xarray index to a pandas.Index object or raise a TypeError
        if this is not supported.

        This method is used by all xarray operations that expect/require a
        pandas.Index object.

        z( cannot be cast to a pandas.Index object)	TypeErrorr:   s    r*   to_pandas_indexzIndex.to_pandas_indexL   s     4KKKLLLr-   indexers1Mapping[Any, int | slice | np.ndarray | Variable]Index | Nonec                    d S r&   rA   )r;   rH   s     r*   iselz
Index.iselV   s	     tr-   labelsdict[Any, Any]r   c                &    t          | d          )Nz& doesn't support label-based selectionr'   )r;   rM   s     r*   selz	Index.sel[   s    !T"S"S"STTTr-   innerr;   otherhowstrc                &    t          | d          )Nz7 doesn't support alignment with inner/outer join methodr'   )r;   rR   rS   s      r*   joinz
Index.join^   s     !NNN
 
 	
r-   dict[Hashable, Any]c                &    t          | d          )Nz# doesn't support re-indexing labelsr'   r;   rR   s     r*   reindex_likezIndex.reindex_likec   s    !T"P"P"PQQQr-   c                    t                      r&   r'   rY   s     r*   equalszIndex.equalsf   r=   r-   shiftsMapping[Any, int]c                    d S r&   rA   )r;   r]   s     r*   rollz
Index.rolli   s    tr-   	name_dictMapping[Any, Hashable]	dims_dictc                    | S r&   rA   )r;   ra   rc   s      r*   renamezIndex.renamel   s	     r-   c                .    |                      d          S )NFdeep_copyr:   s    r*   __copy__zIndex.__copy__q   s    zzuz%%%r-   memodict[int, Any] | Nonec                0    |                      d|          S )NTrh   rl   ri   )r;   rl   s     r*   __deepcopy__zIndex.__deepcopy__t   s    zzt$z///r-   Trh   boolc                .    |                      |          S )Nrg   ri   )r;   rh   s     r*   copyz
Index.copyw   s    zztz$$$r-   c           	        | j         }|                    |          }|rD| j                                        D ])\  }}t	          ||t          j        ||                     *n|j                            | j                   |S r&   )	__class____new____dict__itemssetattrrs   deepcopyupdate)r;   rh   rl   r)   copiedkvs          r*   rj   zIndex._copyz   s     nS!! 	2++-- ; ;14=D#9#9::::; O""4=111r-   indexerr   c                    t                      r&   r'   r;   r   s     r*   __getitem__zIndex.__getitem__   r=   r-   c                    | j         j        S r&   )ru   __name__)r;   	max_widths     r*   _repr_inline_zIndex._repr_inline_   s    ~&&r-   )r    r!   r"   r#   r$   r   r&   )
r)   r.   r/   r0   r1   r   r2   r3   r$   r   )r    r!   r1   r   r$   r   r$   r8   r    r>   r$   r?   r$   rD   )rH   rI   r$   rJ   rM   rN   r$   r   rQ   )r;   r   rR   r   rS   rT   r$   r   )r;   r   rR   r   r$   rW   )r]   r^   r$   rJ   )ra   rb   rc   rb   r$   r   )r$   r   )rl   rm   r$   r   )T)r;   r   rh   rq   r$   r   TN)r;   r   rh   rq   rl   rm   r$   r   r   r   )r   
__module____qualname____doc__classmethodr+   r5   r7   r<   rC   rG   rL   rP   rV   rZ   r\   r`   re   rk   rp   rs   rj   r   r   rA   r-   r*   r   r   !   s         $ $ $ [$ 
 59	$ $ $ $ [$ 
 
 
 [

$ $ $ $ :>    M M M M   
U U U U
 
 
 
 

R R R R$ $ $      
& & & &0 0 0 0 0% % % % % IM
 
 
 
 
$ $ $ $' ' ' ' 'r-   r   indexrD   r$   c                    ddl m} t          |           dk    r@| j        dk    r5t	          | |          s%	  ||           S # t
          t          f$ r | cY S w xY w| S )Nr   )CFTimeIndexO)xarray.coding.cftimeindexr   lendtype
isinstanceImportErrorrF   )r   r   s     r*   _maybe_cast_to_cftimeindexr      s    555555
5zzA~~%+,,Z{5S5S,	;u%%%Y' 	 	 	LLL	 s   
A AAarrayr   c                2   ddl m} ddlm} t	          | t
          j                  r| }nt	          | ||f          r|                                 }nt	          | t                    r|                                 }nt	          | t                    r| j
        }nri }t          | d          r<| j        j        dk    rd|d<   n&| j        dk    rt          dt          	           d
|d<   t          j        t!          j        |           fi |}t%          |          S )a9  Given an array, safely cast it to a pandas.Index.

    If it is already a pandas.Index, return it unchanged.

    Unlike pandas.Index, if the array has dtype=object or dtype=timedelta64,
    this function will not attempt to do automatic type conversion but will
    always return an index with dtype=object.
    r   	DataArrayr   r   r   objectfloat16z`pandas.Index` does not support the `float16` dtype. Casting to `float64` for you, but in the future please manually cast to either `float32` and `float64`.)categoryfloat64)xarray.core.dataarrayr   xarray.core.variabler   r   pdr   	_to_indexrG   r   r   hasattrr   kindr   DeprecationWarningnpasarrayr   )r   r   r   r   kwargss        r*   safe_cast_to_indexr      sG    0/////------%"" 6	EIx0	1	1 6!!	E5	!	! 6%%''	E0	1	1 6!#5'"" 	,{3&&"*w	))'L 0    #,wE**55f55%e,,,r-   c                ,   ddl m} ddlm} t	          | t
                    s7t          t          j        |                     dk    rt          d|            t	          | ||f          r| j
        } t	          | t          j                  r| d         } | S )Nr   r   r   z=cannot use non-scalar arrays in a slice for xarray indexing: rA   )r   r   r   r   r   tupler   r   shape
ValueErrorvaluesndarray)xr   r   s      r*   _sanitize_slice_elementr      s    //////------a 
C$4$4$9$9OAOO
 
 	
 !h	*++ H!RZ   bEHr-    c                   ||t          d          |                     t          |j                  t          |j                  t          |j                            }t          |t                    st          d|d          |S )Nz@cannot use ``method`` argument if any indexers are slice objectsz<cannot represent labeled-based slice indexer for coordinate zI with a slice over integer positions; the index is unsorted or non-unique)	r(   slice_indexerr   startstopstepr   sliceKeyError)r   label
coord_namemethod	tolerancer   s         r*   _query_slicer      s    Y2!N
 
 	
 !!,,
++
++ G
 gu%% 
 %% % %
 
 	

 Nr-   c                    t          | t                    rt          j        |           }nNt	          j        |           }|j        dk    r/t	          j        t          |           t                    }| |dd<   |S )z
    Convert values into a numpy array of at most 1-dimension, while preserving
    tuples.

    Adapted from pandas.core.common._asarray_tuplesafe
       r   N)
r   r   r   to_0d_object_arrayr   r   ndimemptyr   r   )r   results     r*   _asarray_tuplesafer      sp     &%   )&11F##;!Xc&kk888FF111IMr-   c                ^    t          | t                    ot          d | D                       S )Nc              3  Z   K   | ]&}t          |t          t          t          f          V  'd S r&   )r   r   listr   ).0values     r*   	<genexpr>z#_is_nested_tuple.<locals>.<genexpr>   sD       5 549
55$.//5 5 5 5 5 5r-   )r   r   any)possible_tuples    r*   _is_nested_tupler      sA    ne,,  5 5=K5 5 5 2 2 r-   
np.ndarrayc                    t          | dd          dk    rt          |           } |1|j        dk    r&| j        j        dk    rt	          j        | |          } | S )Nr      fbr   )getattrr   r   r   r   r   )r   r   s     r*   normalize_labelr     sb    ufa  A%%"5))UZ3..5;3Cs3J3J
 
5...Lr-   r   c                V    | j         j        dv r| d         n|                                 S )NmMrA   )r   r   item)r   s    r*   	as_scalarr     s'    (D00599ejjllBr-   c                    t          j        |          }|j        dk    r|                    d          }|                     |||          }|                    |j                  }|S )zXWrapper around :meth:`pandas.Index.get_indexer` supporting n-dimensional
    labels
    r   r   )r   r   )r   ravelr   astypeget_indexerreshaper   )r   rM   r   r   flat_labelsflat_indexerr   s          r*   get_indexer_ndr     sh     (6""KI%%!((33$$[9$UUL""6<00GNr-   T_PandasIndexPandasIndex)boundc                     e Zd ZU dZded<   ded<   ded<   dZd=d>dZd?dZed@d            Z	e
d=dAd            Ze	 d=dBd            Z	 d=dCdZdAdZdDd Z	 d?dEd$ZdFd'ZdGdHd,Z	 d?dId.ZdJd1Zd2 Z	 dKdLd9ZdMd;Zd< Zd	S )Nr   z2Wrap a pandas.Index as an xarray compatible index.rD   r   r   r1   r   coord_dtype)r   r1   r   Nr   c                    t          |                                          }|j        ||_        || _        || _        |t          |          }|| _        d S r&   )r   rs   namer   r1   r   r   )r;   r   r1   r   r   s        r*   __init__zPandasIndex.__init__+  s[     #5))..00:EJ
/66K&r-   c                Z    || j         }|| j        } t          |           |||          S r&   )r1   r   type)r;   r   r1   r   s       r*   _replacezPandasIndex._replace;  s6    ;(C*KtDzz%k222r-   r    r!   r"   r#   r$   c               x   t          |          dk    r t          dt          |           d          t          t          |                                                    \  }}|j        dk    rt          d|d|j         d          |j        d         }t          |j        d|j	                  }t          |j        t                    r-|j        j        }||j        j                            |          } | |||j        	          }t          |j        t"          j                  rJ ||j        _        |S )
Nr   z-PandasIndex only accepts one variable, found z
 variablesz<PandasIndex only accepts a 1-dimensional variable, variable z has z dimensionsr   r   r   )r   r   nextiterrx   r   dimsr   _datadatar   r   levelr   get_level_valuesr   r   r   
MultiIndexr   )	r)   r    r"   r   varr1   r   r   objs	            r*   r+   zPandasIndex.from_variablesB  sB    y>>QZIZZZ   ioo//0011	c8q==? ? ?),? ? ?  
 hqk sy'3844ci!;<< 	?IOE y77>>c$333ci77777	
r-   c                   | st          j        g           }nt          fd| D                       s4d                    d | D                       }t	          dd|           d | D             }|d                             |dd                    }|;t          j        t          j	        |                    }|
                    |          }|S )	Nc              3  .   K   | ]}|j         k    V  d S r&   r1   )r   idxr1   s     r*   r   z.PandasIndex._concat_indexes.<locals>.<genexpr>q  s)      99#sw#~999999r-   ,c                    h | ]
}|j         S rA   r  r   r  s     r*   	<setcomp>z.PandasIndex._concat_indexes.<locals>.<setcomp>r  s     C C CCCG C C Cr-   z#Cannot concatenate along dimension z indexes with dimensions: c                    g | ]	}|j         
S rA   r   r  s     r*   
<listcomp>z/PandasIndex._concat_indexes.<locals>.<listcomp>w  s    777#)777r-   r   r   )r   r   allrV   r   appendr   inverse_permutationr   concatenatetake)r/   r1   r2   new_pd_indexr   
pd_indexesindicess    `     r*   _concat_indexeszPandasIndex._concat_indexesj  s      	:8B<<LL999999999 xx C C7 C C CDD *# * *#'* *   87w777J%a=//
122??L$!5bnY6O6OPP+0099r-   r/   Sequence[PandasIndex]r2   r3   c                    |                      |||          }|sd }nt          j        d |D              } | |||          S )Nc                    g | ]	}|j         
S rA   r   r  s     r*   r	  z&PandasIndex.concat.<locals>.<listcomp>  s    *N*N*Ns3?*N*N*Nr-   )r1   r   )r  r   result_type)r)   r/   r1   r2   r  r   s         r*   r5   zPandasIndex.concat  s]     **7CCC 	PKK.*N*Ng*N*N*NOKs<SkBBBBr-   r>   r?   c                    ddl m} | j        j        }|||v r||         }|j        }|j        }nd }d }t          | j        | j                  } || j        |||          }||iS )Nr   IndexVariabler   )attrsencoding)	r   r  r   r   r  r  r   r   r1   )r;   r    r  r   r   r  r  r   s           r*   rC   zPandasIndex.create_variables  s     	766666z  TY%6%6D/CIE|HHEH$TZt7GHHHmDHd%(KKKc{r-   c                    | j         S r&   r  r:   s    r*   rG   zPandasIndex.to_pandas_index  s
    zr-   rH   rI   PandasIndex | Nonec                   ddl m} || j                 }t          ||          r|j        | j        fk    rd S |j        }t          |t                    st          |          rd S |                     | j	        |                   S )Nr   r   )
r   r   r1   r   r   r   r   r   r   r   )r;   rH   r   indxrs       r*   rL   zPandasIndex.isel  s     	211111"eX&& 	#zdh[((t
%'' 	Ie,<,< 	4}}TZ.///r-   rM   rN   r   c                   ddl m} ddlm} |$t	          |t
                    st          d          t          |          dk    sJ t          t          |
                                                    \  }}t	          |t                    rt          | j        ||||          }nt          |          rt          d          t!          || j                  }	|	j        dk    rt'          |	          }
t	          | j        t(          j                  r=|t          d          |t          d	          | j                            |
          }n|Bt/          | j        |	||          }t1          j        |dk               rt5          d
|          n	 | j                            |
          }nz# t4          $ r}t5          d
|d          |d }~ww xY w|	j        j        dk    r|	}nAt/          | j        |	||          }t1          j        |dk               rt5          d
|          t	          ||          r ||j        |          }n(t	          ||          r |||j        |j                  }t?          | j         |i          S )Nr   r   r   z``method`` must be a stringr   zZcannot use a dict-like object for selection on a dimension that does not have a MultiIndexr   zA'method' is not supported when indexing using a CategoricalIndex.zD'tolerance' is not supported when indexing using a CategoricalIndex.not all values found in index zH. Try setting the `method` keyword argument (example: method='nearest').r   coordsr   )!r   r   r   r   r   rT   rF   r   r   r   rx   r   r   r   r   r   r   r   r   r   r   CategoricalIndexget_locr   r   r   r   r   r   r   _coordsr   r1   )r;   rM   r   r   r   r   r   r   r   label_arraylabel_valuees               r*   rP   zPandasIndex.sel  s    	433333111111j&=&=9:::6{{a fllnn!5!566
EeU## 2	T"4:uj&)TTGG%   0	T>  
 *%t7GHHHK1$$'44dj"*=>> %)(_   !,(b   #j00==GG)"0 JVY# # 6'A+.. "* O O O# # 
%&*j&8&8&E&EGG' % % %"*!i !i !i !i# # $%%% "'3..%([&)TT6'A+&& T"#RJ#R#RSSS %** T"(5:w77E9-- T#)GEM
SSStx1222s   F2 2
G<GGrR   r   c                    t          |t                    sdS | j                            |j                  o| j        |j        k    S )NF)r   r   r   r\   r1   rY   s     r*   r\   zPandasIndex.equals  s?    %-- 	5z  --G$(ei2GGr-   rQ   r;   rS   rT   c                
   |dk    r | j                             |j                   }n| j                             |j                   }t          j        | j        |j                  } t          |           || j        |          S )Nouterr   )r   unionintersectionr   r  r   r   r1   )r;   rR   rS   r   r   s        r*   rV   zPandasIndex.join  ss    '>>J$$U[11EE J++EK88EnT%5u7HIItDzz%{CCCCr-   rW   c                    | j         j        st          d| j        d          | j        t	          | j         |j         ||          iS )Nz(cannot reindex or align along dimension z0 because the (pandas) index has duplicate values)r   	is_uniquer   r1   r   )r;   rR   r   r   s       r*   rZ   zPandasIndex.reindex_like  s\     z# 	648 6 6 6  
 .U[&)TTUUr-   r]   r^   c                    || j                  | j        j        d         z  }|dk    r2| j        | d                              | j        d |                    }n| j        d d          }|                     |          S )Nr   )r1   r   r   r  r   )r;   r]   shift
new_pd_idxs       r*   r`   zPandasIndex.roll  sv    tx 4:#3A#66A::UFGG,33DJww4GHHJJAAAJ}}Z(((r-   c                *   | j         j        |vr| j        |vr| S |                    | j         j        | j         j                  }| j                             |          }|                    | j        | j                  }|                     ||          S )Nr  )r   r   r1   getre   r   )r;   ra   rc   new_namer   new_dims         r*   re   zPandasIndex.rename   s    :?)++	0I0IK==$*/BB
!!(++--$(33}}U}000r-   Tr   rh   rq   rl   rm   c                v    |r| j                             d          }n| j         }|                     |          S )NTrg   )r   rs   r   )r;   rh   rl   r   s       r*   rj   zPandasIndex._copy)  s>      	JOOO..EE JE}}U###r-   r   c                B    |                      | j        |                   S r&   )r   r   r   s     r*   r   zPandasIndex.__getitem__4  s    }}TZ0111r-   c                2    dt          | j                   dS )NzPandasIndex())reprr   r:   s    r*   __repr__zPandasIndex.__repr__7  s    1d4:..1111r-   r&   )r   r   r1   r   r   r   NN)r    r!   r"   r#   r$   r   r   )r/   r  r1   r   r2   r3   r$   r   r   )rH   rI   r$   r  r   )rR   r   r   )r;   r   rR   r   rS   rT   r$   r   )rR   r   r$   rW   )r]   r^   r$   r   r   )r;   r   rh   rq   rl   rm   r$   r   r   )r   r   r   r   __annotations__	__slots__r   r   r   r+   staticmethodr  r5   rC   rG   rL   rP   r\   rV   rZ   r`   re   rj   r   r=  rA   r-   r*   r   r   "  s        <<OOOMMM/I' ' ' ' ' 3 3 3 3 % % % [%N     \* 
 59	C C C C [C  :>    *   0 0 0 0& >B@3 @3 @3 @3 @3DH H H H
D D D D D :>	V 	V 	V 	V 	V) ) ) )1 1 1 OS	$ 	$ 	$ 	$ 	$2 2 2 22 2 2 2 2r-   equalr    r!   all_dimsrT   c                <   t          d |                                 D                       rt          d          d |                                 D             }|dk    rTt          |          dk    rAt          dd                    d |                                 D                       z             |d	k    rat          |          t          |           k     rCt          d
d                    d |                                 D                       z             dS dS )zCheck that all multi-index variable candidates are 1-dimensional and
    either share the same (single) dimension or each have a different dimension.

    c                $    g | ]}|j         d k    S r   )r   r   r   s     r*   r	  z%_check_dim_compat.<locals>.<listcomp>@  s    888cCHM888r-   z5PandasMultiIndex only accepts 1-dimensional variablesc                    h | ]	}|j         
S rA   r   rG  s     r*   r  z$_check_dim_compat.<locals>.<setcomp>C  s    333CH333r-   rB  r   z/unmatched dimensions for multi-index variables , c                ,    g | ]\  }}|d |j          S  rI  r   r}   r~   s      r*   r	  z%_check_dim_compat.<locals>.<listcomp>H  ,    IIItq!A**!&**IIIr-   	differentz9conflicting dimensions for multi-index product variables c                ,    g | ]\  }}|d |j          S rL  rI  rN  s      r*   r	  z%_check_dim_compat.<locals>.<listcomp>N  rO  r-   N)r   r   r   r   rV   rx   )r    rC  r   s      r*   _check_dim_compatrR  ;  s.   
 88Y%5%5%7%788899 RPQQQ33	 0 0 2 2333D7s4yy1}}=iiIIy7H7HIIIJJK
 
 	

 ;3t99s9~~#=#=GiiIIy7H7HIIIJJK
 
 	
 #=#=r-   c                P   t          | t          j                  r|                                 } t	          d | j        D                       rg }t          | j                  D ]m\  }}t          |t          j                  r&|| j        |                  	                                }n|| j        |                  }|
                    |           nt          j                            || j                  } n.t          | t          j                  r| 	                                } | S )zZ
    Remove unused levels from MultiIndex and unused categories from CategoricalIndex
    c              3  J   K   | ]}t          |t          j                  V  d S r&   )r   r   r$  r   levs     r*   r   z2remove_unused_levels_categories.<locals>.<genexpr>Z  s/      LLz#r233LLLLLLr-   names)r   r   r   remove_unused_levelsr   levels	enumerater$  codesremove_unused_categoriesr  from_arraysrX  )r   rZ  ir   s       r*   remove_unused_levels_categoriesr`  R  s    %'' 1**,, LLu|LLLLL 	IF%el33 % %5eR%899 2!%+a.1JJLLEE!%+a.1Ee$$$$ M--fEK-HHE	E2.	/	/ 1..00Lr-   c                       e Zd ZU dZded<   dZd+d, fd
Zd-d.dZed/d            Z	e	 d+d0d            Z
ed1d            Zd2dZed3d            Zd4dZd5d Z	 d+d6d#Zd-d7d%Zd8d9d)Zd* Z xZS ):PandasMultiIndexz7Wrap a pandas.MultiIndex as an xarray compatible index.zdict[str, Any]level_coords_dtype)r   r1   r   rc  Nr   r   r1   r   c                `   t                                          ||           g }t          | j        j                  D ]C\  }}|j        p| d| }||k    rt          d|d|          |                    |           D|| j        _        |d | j        j        D             }|| _	        d S )N_level_z#conflicting multi-index level name z with dimension c                8    i | ]}|j         t          |          S rA   )r   r   r  s     r*   
<dictcomp>z-PandasMultiIndex.__init__.<locals>.<dictcomp>  s2     " " "9</44" " "r-   )
superr   r[  r   rZ  r   r   r  rX  rc  )	r;   r   r1   rc  rX  r_  r  r   ru   s	           r*   r   zPandasMultiIndex.__init__t  s    $$$ 
 122 	 	FAs81#11a11Ds{{ Y$YYRUYY   LL 
%" "@D
@Q" " " #5r-   r$   c                h    || j         }||_        || j        } t          |           |||          S r&   )r1   r   rc  r   )r;   r   r1   rc  s       r*   r   zPandasMultiIndex._replace  s?    ;(C
%!%!8tDzz%&8999r-   r    r!   r"   r#   c                  t          |           t          t          |                                                    j        d         }t
          j                            d |                                D             |                                          }||_	        d |
                                D             } | |||          }|S )Nr   c                    g | ]	}|j         
S rA   )r   rG  s     r*   r	  z3PandasMultiIndex.from_variables.<locals>.<listcomp>  s    666CSZ666r-   rW  c                $    i | ]\  }}||j         S rA   r   )r   r   r   s      r*   rg  z3PandasMultiIndex.from_variables.<locals>.<dictcomp>  s     QQQ)$dCIQQQr-   rc  )rR  r   r   r   r   r   r   r^  keysr   rx   )r)   r    r"   r1   r   rc  r   s          r*   r+   zPandasMultiIndex.from_variables  s     	)$$$4	((**++,,1!4))669#3#3#5#5666inn>N>N * 
 
 
QQy?P?PQQQc%1CDDD
r-   r/   Sequence[PandasMultiIndex]r2   r3   c                    |                      |||          }|sd }n/i }|d         j        D ]t          j        fd|D              |<     | |||          S )Nr   c                *    g | ]}|j                  S rA   rm  )r   r  r   s     r*   r	  z+PandasMultiIndex.concat.<locals>.<listcomp>  s!    FFFsc,T2FFFr-   r1   rc  )r  rc  r   r  )r)   r/   r1   r2   r  rc  r   s         @r*   r5   zPandasMultiIndex.concat  s     **7CCC 	!%!#
5  +->FFFFgFFF,"4(( s<S=OPPPPr-   c                   t          |d           d |                                D             }t          ||          D ]5\  }}t          |t          j                  rt          d|d|d          6t          d |D              \  }}t          j        |dd	i}d
 |D             }	t	          j        ||	d|	                                          }
d |
                                D             } | |
||          S )aH  Create a new Pandas MultiIndex from the product of 1-d variables (levels) along a
        new dimension.

        Level variables must have a dimension distinct from each other.

        Keeps levels the same (doesn't refactorize them) so that it gives back the original
        labels after a stack/unstack roundtrip.

        rP  )rC  c                ,    g | ]}t          |          S rA   )r   rG  s     r*   r	  z*PandasMultiIndex.stack.<locals>.<listcomp>  s!    OOOS+C00OOOr-   z4cannot create a multi-index along stacked dimension z from variable z that wraps a multi-indexc                6    g | ]}|                                 S rA   )	factorizerU  s     r*   r	  z*PandasMultiIndex.stack.<locals>.<listcomp>  s     $N$N$NS]]__$N$N$Nr-   indexingijc                6    g | ]}|                                 S rA   )r   )r   r   s     r*   r	  z*PandasMultiIndex.stack.<locals>.<listcomp>  s     111!''))111r-   r   )	sortorderrX  c                $    i | ]\  }}||j         S rA   r   r   r}   r   s      r*   rg  z*PandasMultiIndex.stack.<locals>.<dictcomp>  s     KKKvq#aKKKr-   rm  )rR  r   zipr   r   r   r   r   meshgridrn  rx   )r)   r    r1   level_indexesr   r  split_labelsrZ  labels_meshrM   r   rc  s               r*   r7   zPandasMultiIndex.stack  sF    	)k::::OOI<L<L<N<NOOOY66 	 	ID##r}--  G3 G G%)G G G    #$N$N$N$N$NOfk<?$??11[111ffAQAQRRRKK9J9JKKKs5#2DEEEEr-   r8   c                    t          | j                  }i }t          |j        |j                  D ]9\  }}t          |                                || j        |                   }|||<   :||fS )Nr   )r`  r   r}  rX  rZ  r   rs   rc  )r;   clean_indexnew_indexesr   rV  r  s         r*   r<   zPandasMultiIndex.unstack  s~    5djAA-/[.0BCC 	$ 	$ID#

Dd.Ed.K  C !$KK''r-   current_variables"tuple[PandasMultiIndex, IndexVars]c           	        g }g }g }i }t          i ||           t          |          dk    rt          t          t	          t          |                                                    j                  }|j        }	|	                    |	j
                   |	                    |	j                   |	                    |	j                   |	j
        D ]}
||
         ||
<   nt          |          dk    rt	          t          |                                                    }| d}|                    |           t          j        |j        d          }|                    |j                   |                    |j                   |||<   |                                D ]n\  }
}|                    |
           t          j        |j        d          }|                    |j                   |                    |j                   |||
<   ot          j        |||          }d |                                D             } | |||          }|                    |          }||fS )zCreate a new multi-index maybe by expanding an existing one with
        new variables as index levels.

        The index and its corresponding coordinates may be created along a new dimension.
        r   _level_0T)orderedrW  c                $    i | ]\  }}||j         S rA   r   r|  s      r*   rg  z@PandasMultiIndex.from_variables_maybe_expand.<locals>.<dictcomp>  s     QQQvq#aQQQr-   rm  )rR  r   r   r   r   r   r   r   r   extendrX  r\  rZ  r  r   Categorical
categoriesrx   r   rC   )r)   r1   r  r    rX  r\  rZ  level_variablesr   current_indexr   r   new_var_namecatr   rc  r   
index_varss                     r*   from_variables_maybe_expandz,PandasMultiIndex.from_variables_maybe_expand  sr    !#!#"$/1<.<)<=== !!A%%*D6G6N6N6P6P1Q1Q,R,R,X D !JMLL,---LL,---MM-.///%+ @ @(9$(?%%@ "##q((t-44667788C!+++LLL&&&.T:::CLL###MM#.))),/OL)"** 	( 	(ID#LL.T:::CLL###MM#.)))$'OD!!fe5999QQ9N9N9P9PQQQc%1CDDD))/::
Jr-   r  PandasMultiIndex | PandasIndexc                l     j                             fd j         j        D                       }t          |t          j                  r* fd|j        D             }                     ||          S t          |                     j	                   j	         j
        |j                           S )zpKeep only the provided levels and return a new multi-index with its
        corresponding coordinates.

        c                    g | ]}|v|	S rA   rA   )r   r}   r  s     r*   r	  z0PandasMultiIndex.keep_levels.<locals>.<listcomp>"  s#    EEE1A_,D,DQ,D,D,Dr-   c                ,    i | ]}|j         |         S rA   rm  r   r}   r;   s     r*   rg  z0PandasMultiIndex.keep_levels.<locals>.<dictcomp>&  s#    !U!U!UA!T%<Q%?!U!U!Ur-   rm  r   )r   	droplevelrX  r   r   r   r   r   re   r1   rc  r   r;   r  r   rc  s   ``  r*   keep_levelszPandasMultiIndex.keep_levels  s     
$$EEEE
(EEE
 
 eR]++ 		!U!U!U!U!U!U!U==;M=NNN TX&& 3EJ?   r-   c                      j                             |                                          } fd|j        D             }                     ||          S )z|Re-arrange index levels using input order and return a new multi-index with
        its corresponding coordinates.

        c                ,    i | ]}|j         |         S rA   rm  r  s     r*   rg  z3PandasMultiIndex.reorder_levels.<locals>.<dictcomp>8  s#    QQQa!8!;QQQr-   rm  )r   reorder_levelsrn  rX  r   r  s   `   r*   r  zPandasMultiIndex.reorder_levels0  sY     
))/*>*>*@*@AAQQQQU[QQQ}}U7I}JJJr-   r>   r?   c                @   ddl m} |i }i }| j        f| j        j        z   D ]{}|| j        k    rd }d }n|}| j        |         }|                    |d           }||j        }|j        }	ni }i }	t          | j        ||          }
 || j        |
||	d          ||<   ||S )Nr   r  )r   r   T)r  r  fastpath)
r   r  r1   r   rX  rc  r5  r  r  r   )r;   r    r  r  r   r   r   r   r  r  r   s              r*   rC   z!PandasMultiIndex.create_variables;  s     	766666I "
XK$*"22 	 	Dtx/5--d++C	<-djUSSSD,}!     Jt r-   r   c                    ddl m} ddlm} ||t	          d          d i }t           fd|D                       ri |                                D ]U\  }}t          | j        |                   }		 t          |	          |<   5# t          $ r t	          d|d          w xY wt          d	                                 D                       }
t                     j        j        k    rA|
s? j                            t!          fd
 j        j        D                                 }n j                            t!                                                    t!                                                              \  }|                               |j        j        dk    r*|                                dk    rt1          | d          nAt          |          dk    rct3          t5          t7          |          t7           j        j                  z
                      }t	          d|d j        j        d          t3          t5          |                                                    \  }}t9          |          r7 fd|D             }|rt	          d|                                |          S t=          |t>                    rtA           j        ||          }n't=          |t                     rtC          |          r j        "                    |          }nt          |           j        j        k    r j                            |          }n fdtG          t          |                    D             } j                            ||          \  }|                    d tI          ||          D                        n8t          |          }	|	j%        dk    rDt          |	          } j                            |d          \  }|| j        j        d         <   np|	j        j        dk    r|	}n]|	j%        dk    rt	          d|d          tM           j        |	          }tO          j
        |dk               rt1          d|          t=          ||          r ||j(        |          }nHt=          ||          r8 fd|j)                                        D             } ||||j(                  }&t=          tT          j+                  r/ fdj        D             } ,                    |          i }g }nBt[          j.         j        j.                            j/        j        j.        i} j/        g}0                                }tc          td          tf          th          f         fd|D                       }|}|                                D ]\  }} |g |          ||<   tk           j/        |i||tm          |          ||          S tk           j/        |i          S )Nr   r   r   z9multi-index does not support ``method`` and ``tolerance``c                ,    g | ]}|j         j        v S rA   r   rX  )r   lblr;   s     r*   r	  z(PandasMultiIndex.sel.<locals>.<listcomp>l  s#    :::Ctz'':::r-   r   z7Vectorized selection is not available along coordinate z (multi-index level)c                8    g | ]}t          |t                    S rA   )r   r   )r   r~   s     r*   r	  z(PandasMultiIndex.sel.<locals>.<listcomp>y  s"    QQQaZ511QQQr-   c              3  (   K   | ]}|         V  d S r&   rA   )r   r}   label_valuess     r*   r   z'PandasMultiIndex.sel.<locals>.<genexpr>}  s'      DDa,q/DDDDDDr-   )r   r   z
 not foundr   z*cannot provide labels for both coordinate z7 (multi-index array) and one or more coordinates among z (multi-index levels)c                0    g | ]}|j         j        v|S rA   r  )r   r   r;   s     r*   r	  z(PandasMultiIndex.sel.<locals>.<listcomp>  s/     " " "!d$*:J.J.JD.J.J.Jr-   z invalid multi-index level names c                4    g | ]}j         j        |         S rA   r  )r   r_  r;   s     r*   r	  z(PandasMultiIndex.sel.<locals>.<listcomp>  s#    MMMadj.q1MMMr-   c                    i | ]\  }}||	S rA   rA   rN  s      r*   rg  z(PandasMultiIndex.sel.<locals>.<dictcomp>  s    /T/T/TA1/T/T/Tr-   z with a multi-indexr!  c                8    i | ]\  }}|j         j        v||S rA   r  )r   r}   r~   r;   s      r*   rg  z(PandasMultiIndex.sel.<locals>.<dictcomp>  s9        AqDJ$444 1444r-   r"  c                ,    i | ]}|j         |         S rA   rm  r  s     r*   rg  z(PandasMultiIndex.sel.<locals>.<dictcomp>  s0     & & &67At.q1& & &r-   rm  r   c                    i | ]}|S rA   rA   r   r}   	new_indexs     r*   rg  z(PandasMultiIndex.sel.<locals>.<dictcomp>  s    -M-M-Mqa-M-M-Mr-   )r/   r    drop_indexesdrop_coordsrename_dims)7r   r   r   r   r   r
  rx   r   rc  r   r   r   r   r   nlevelsr%  r   rX  get_loc_levelrn  r{   r   r   sumr   r   r   setr   rP   r   r   r   r   get_locsranger}  r   r   r   r   r&  r   r   r   r   r   r1   rC   r   rB   r   r   r   r   )r;   rM   r   r   r   r   scalar_coord_valuesr}   r~   r'  	has_slicer   r   r   invalid_levelsrZ  r(  r#  rc  rc   r  new_varsr/   r    r   valr  r  s   `                         @@r*   rP   zPandasMultiIndex.sel_  s`   333333111111!6K   	  ::::6:::;; [	QL 	 	1-at7Nq7QRRR&/&<&<LOO!   $P67P P P   QQ<;N;N;P;PQQQRRI<  DJ$666y6*,,DDDD4:3CDDDDD  &*Z%=%=,--//00l>O>O>Q>Q8R8R &> & &" $**<888=%,,!1C1C"f#8#8#8999 6{{Q!$s6{{S9I5J5J'J"K"KLL
 c c c9=9Ic c c  
 !%T&,,..%9%9 : :JE"" 4Q" " " "%*" " " " $K>KK   xx&E5)) *Q&tz5*EEE5)) 'Q#E** V"j11%88GGZZ4:#555"j0077GGMMMM5U;L;LMMMF)-)A)A%v)A)V)V&GY'../T/TVUASAS/T/T/TUUUU .e44#q(("+K"8"8K)-)A)A+UV)A)W)W&GY?J'
(8(;<< &+s22)GG"'!++(L*4L L L   -TZEEGvgk** X&'V
'V'VWWW eX.. 
Q&huz7;;GGy11 Q   $)M$7$7$9$9  F
 (iUZPPPG )R]33 )& & & &;D?& & &" !MM2D *  	 	 'N $ 7	 G  	
 "Xy';<	#xj !1133H4U
+-M-M-M-MH-M-M-MNNG !I06688 4 4	c"*(2s"3"3	$!7##!"566'%    "48W"5666s   ;BB,rQ   rS   rT   c                f   |dk    rGj                                         }d |_        | j                             |          }| j        |_        n| j                             j                   }fd| j                                        D             } t          |           || j        |          S )Nr,  c                X    i | ]&\  }}|t          j        |j        |                   'S rA   )r   r  rc  )r   r}   	lvl_dtyperR   s      r*   rg  z)PandasMultiIndex.join.<locals>.<dictcomp>  sC     
 
 
9 r~i)A!)DEE
 
 
r-   rm  )	r   rs   r   r-  r1   r.  rc  rx   r   )r;   rR   rS   other_indexr   rc  s    `    r*   rV   zPandasMultiIndex.join  s    '>>+**,,K#KJ$$[11EEJJ J++EK88E
 
 
 
 $ 7 = = ? ?
 
 

 tDzz%>PQQQQr-   c                   t          | j        j                  t                    z  s| j        |vr| S fd| j        j        D             }| j                            |          }|                    | j        | j                  }d t          || j                                                  D             }| 	                    |||          S )Nc                <    g | ]}                     ||          S rA   )r5  )r   r}   ra   s     r*   r	  z+PandasMultiIndex.rename.<locals>.<listcomp>	  s'    CCCQY]]1a((CCCr-   c                    i | ]\  }}||	S rA   rA   rN  s      r*   rg  z+PandasMultiIndex.rename.<locals>.<dictcomp>  s+     "
 "
 "
QAq"
 "
 "
r-   rr  )
r  r   rX  r1   re   r5  r}  rc  r   r   )r;   ra   rc   	new_namesr   r7  new_level_coords_dtypes    `     r*   re   zPandasMultiIndex.rename  s    4:#$$s9~~5 	$():S:SK DCCC$*2BCCC	
!!),,--$(33"
 "
 D,C,J,J,L,LMM"
 "
 "
 }}w3I  
 
 	
r-   r&   )r   r   r1   r   rc  r   r>  )r$   rb  )r    r!   r"   r#   r$   rb  )r/   ro  r1   r   r2   r3   r$   rb  )r    r!   r1   r   r$   rb  r   )r1   r   r  r!   r    r!   r$   r  )r  r!   r$   r  )r  r!   r$   rb  r   )r$   r   r   )rS   rT   )r   r   r   r   r?  r@  r   r   r   r+   r5   r7   r<   r  r  r  rC   rP   rV   re   __classcell__)ru   s   @r*   rb  rb  m  s        AA&&&&EI5 5 5 5 5 5 5(: : : : :    [$ 
 59	Q Q Q Q [Q& F F F [F>
( 
( 
( 
( 4 4 4 [4l   ,	K 	K 	K 	K :>" " " " "HQ7 Q7 Q7 Q7 Q7fR R R R R$
 
 
 
 
 
 
r-   rb  dim_variableall_variables#Mapping | Iterable[Hashable] | Nonetuple[PandasIndex, IndexVars]c                   
 i t          t                    sd D              j        d         
t           j        dd          }t          |t
          j                  rt          |
          }|                                }
fd|D             }|rt          |          t          |j
        j                  k     rd}n)fd|D             }t           fd|D                       }|r'd	                    |          }t          d
|           n5
 i}	t                              |	i           }|                    |	          }||fS )a  Create a default index from a dimension variable.

    Create a PandasMultiIndex if the given variable wraps a pandas.MultiIndex,
    otherwise create a PandasIndex (note that this will become obsolete once we
    depreciate implicitly passing a pandas.MultiIndex as a coordinate).

    Nc                    i | ]}|d S r&   rA   r   r}   s     r*   rg  z1create_default_index_implicit.<locals>.<dictcomp>#  s    888QD888r-   r   r   c                (    g | ]}|v |k    |S rA   rA   )r   r}   r  r   s     r*   r	  z1create_default_index_implicit.<locals>.<listcomp>-  s)    UUUA4F4F1PT991999r-   Tc                     g | ]
}|         S rA   rA   )r   r}   r  s     r*   r	  z1create_default_index_implicit.<locals>.<listcomp>6  s    !L!L!Lq-"2!L!L!Lr-   c              3  L   K   | ]}|d u p                     |           V  d S r&   r\   )r   r~   r  s     r*   r   z0create_default_index_implicit.<locals>.<genexpr>7  sN        @AAI;\%8%8%;%;!;     r-   
z1conflicting MultiIndex level / variable name(s):
)r"   )r   r   r   r   r   r   r   rb  rC   r   r   rX  r   rV   r   r   r+   )r  r  r   r   r  duplicate_namesconflictduplicate_varsconflict_strdim_varr   s   ``        @r*   create_default_index_implicitr    s    mW-- 988-888QDL&66E %'' 5 --++--
UUUUUjUUU 	
 ?##c%+*;&<&<<<!L!L!L!LO!L!L!L    ES      #yy99 WWW   &**7B*??++G44
*r-   T_PandasOrXarrayIndexc                     e Zd ZU dZded<   ded<   dZd5d	Zed6d            Zed7d            Z	ed8d            Z
ed9d            Zed:d            Zd;dZd<dZd=dZ	 d>d?d Z	 d>d@d!ZdAd#ZdBd%Z	 dCdDd,ZdEd.ZdFd0ZdGd1ZdHd3Zd4 Zd'S )IIndexeszImmutable proxy for Dataset or DataArrary indexes.

    Keys are coordinate names and values may correspond to either pandas or
    xarray indexes.

    Also provides some utility methods.

     dict[Any, T_PandasOrXarrayIndex]_indexesdict[Any, Variable]
_variables)r  r  _dims__coord_name_id
__id_index__id_coord_namesr/   r    c                Z    || _         || _        d| _        d| _        d| _        d| _        dS )zConstructor not for public consumption.

        Parameters
        ----------
        indexes : dict
            Indexes held by this object.
        variables : dict
            Indexed coordinate variables in this object.

        N)r  r  r  _Indexes__coord_name_id_Indexes__id_index_Indexes__id_coord_names)r;   r/   r    s      r*   r   zIndexes.__init__b  s6      #48
6:CGHLr-   r$   dict[Any, int]c                n    | j         (d | j                                        D             | _         | j         S )Nc                4    i | ]\  }}|t          |          S rA   id)r   r}   r  s      r*   rg  z*Indexes._coord_name_id.<locals>.<dictcomp>|  s$    #S#S#S61cAr#ww#S#S#Sr-   )r  r  rx   r:   s    r*   _coord_name_idzIndexes._coord_name_idy  s8    '#S#ST]=P=P=R=R#S#S#SD ##r-    dict[int, T_PandasOrXarrayIndex]c                d    | j         #d |                                 D             | _         | j         S )Nc                .    i | ]}t          |          |S rA   r  r  s     r*   rg  z%Indexes._id_index.<locals>.<dictcomp>  s     IIIr#wwIIIr-   )r  
get_uniquer:   s    r*   	_id_indexzIndexes._id_index  s1    ?"IIt7H7HIIIDOr-   dict[int, tuple[Hashable, ...]]c                    | j         qt          t                    }| j                                        D ] \  }}||                             |           !d |                                D             | _         | j         S )Nc                4    i | ]\  }}|t          |          S rA   )r   rN  s      r*   rg  z+Indexes._id_coord_names.<locals>.<dictcomp>  s$    $T$T$TTQQa$T$T$Tr-   )r  r   r   r  rx   r  )r;   id_coord_namesr}   r~   s       r*   _id_coord_nameszIndexes._id_coord_names  s     (;Ft;L;LN+1133 , ,1q!((++++$T$T^=Q=Q=S=S$T$T$TD!$$r-   Mapping[Hashable, Variable]c                *    t          | j                  S r&   )r   r  r:   s    r*   r    zIndexes.variables  s    do&&&r-   Mapping[Hashable, int]c                n    ddl m} | j         || j                  | _        t	          | j                  S )Nr   calculate_dimensions)r   r  r  r  r   )r;   r  s     r*   r   zIndexes.dims  s@    ======:--do>>DJdj!!!r-   c                |     t          |           t          | j                  t          | j                            S r&   )r   rB   r  r  r:   s    r*   rs   zIndexes.copy  s.    tDzz$t}--tDO/D/DEEEr-   list[T_PandasOrXarrayIndex]c                    g }t                      }| j                                        D ]?}t          |          }||vr*|                    |           |                    |           @|S )z2Return a list of unique indexes, preserving order.)r  r  r   r  r  add)r;   unique_indexesseenr   index_ids        r*   r  zIndexes.get_unique  sr     79]))++ 	# 	#E%yyHt##%%e,,,"""r-   keyr   rq   c                T    t          | j        | j        |                            dk    S )zZReturn True if ``key`` maps to a multi-coordinate index,
        False otherwise.
        r   )r   r  r  r;   r  s     r*   is_multizIndexes.is_multi  s'     4'(;C(@ABBQFFr-   raiseerrorsr   dict[Hashable, Variable]c                     |dvrt          d          | j        vr|dk    rt          d|d          i S  j         j        |                  } fd|D             S )a  Return all coordinates having the same index.

        Parameters
        ----------
        key : hashable
            Index key.
        errors : {"raise", "ignore"}, default: "raise"
            If "raise", raises a ValueError if `key` is not in indexes.
            If "ignore", an empty tuple is returned instead.

        Returns
        -------
        coords : dict
            A dictionary of all coordinate variables having the same index.

        )r
  ignorez)errors must be either "raise" or "ignore"r
  zno index found for z coordinatec                ,    i | ]}|j         |         S rA   r  r  s     r*   rg  z*Indexes.get_all_coords.<locals>.<dictcomp>  s"    ???!4?1%???r-   )r   r  r  r  )r;   r  r  all_coord_namess   `   r*   get_all_coordszIndexes.get_all_coords  s    & ,,,HIIIdm##   !Is!I!I!IJJJ	.t/B3/GH????????r-   c                N    ddl m}  ||                     ||                    S )a  Return all dimensions shared by an index.

        Parameters
        ----------
        key : hashable
            Index key.
        errors : {"raise", "ignore"}, default: "raise"
            If "raise", raises a ValueError if `key` is not in indexes.
            If "ignore", an empty tuple is returned instead.

        Returns
        -------
        dims : dict
            A dictionary of all dimensions shared by an index.

        r   r  )r  )r   r  r  )r;   r  r  r  s       r*   get_all_dimszIndexes.get_all_dims  s:    & 	>=====##D$7$7F$7$K$KLLLr-   <list[tuple[T_PandasOrXarrayIndex, dict[Hashable, Variable]]]c                     g } j         D ]?} j         |         } fd j        |         D             }|                    ||f           @|S )zEReturns a list of unique indexes and their corresponding coordinates.c                ,    i | ]}|j         |         S rA   r  r  s     r*   rg  z*Indexes.group_by_index.<locals>.<dictcomp>  s"    MMMa+MMMr-   )r  r  r  )r;   index_coordsr_  r   r#  s   `    r*   group_by_indexzIndexes.group_by_index  si    
  	1 	1AN1%EMMMMT5I!5LMMMF0000r-   Indexes[pd.Index]c                   i }| j                                         D ]Q\  }}t          |t          j                  r|||<   %t          |t                    r|                                ||<   Rt          || j                  S )zReturns an immutable proxy for Dataset or DataArrary pandas indexes.

        Raises an error if this proxy contains indexes that cannot be coerced to
        pandas.Index objects.

        )r  rx   r   r   r   rG   r  r  )r;   r/   r}   r  s       r*   to_pandas_indexeszIndexes.to_pandas_indexes  s     -/m))++ 	3 	3FAs#rx(( 3 

C'' 3 0022
w000r-   TNrh   rl   rm   Ftuple[dict[Hashable, T_PandasOrXarrayIndex], dict[Hashable, Variable]]c                n  
 i }i }|                                  D ]\  }}t          |t          j                  rwd}t	          t          |                                                    j        d         }t          |t          j                  rt          ||          }nt          ||          }nd}|                    ||          
|                    |          }	|rt          t          
          j        
|                    
fd|D                        |                    |	           ||fS )a  Return a new dictionary with copies of indexes, preserving
        unique indexes.

        Parameters
        ----------
        deep : bool, default: True
            Whether the indexes are deep or shallow copied onto the new object.
        memo : dict if object id to copied objects or None, optional
            To prevent infinite recursion deepcopy stores all copied elements
            in this dict.

        Tr   Fro   c                    i | ]}|S rA   rA   )r   r}   new_idxs     r*   rg  z(Indexes.copy_indexes.<locals>.<dictcomp>+  s    ;;;q7;;;r-   )r  r   r   r   r   r   r   r   r   rb  r   rj   rC   r   r   r{   )r;   rh   rl   r  new_index_varsr  r#  convert_new_idxr1   idx_varsr   s             @r*   copy_indexeszIndexes.copy_indexes  s4    ..00 	, 	,KC#rx(( ("&400116q9c2=11 0*344CC%c3//CC"'iiTi55G++F33H ;{G44:;;;;F;;;<<<!!(++++N**r-   Iterator[T_PandasOrXarrayIndex]c                *    t          | j                  S r&   )r   r  r:   s    r*   __iter__zIndexes.__iter__0  s    DM"""r-   intc                *    t          | j                  S r&   )r   r  r:   s    r*   __len__zIndexes.__len__3  s    4=!!!r-   c                    || j         v S r&   r  r  s     r*   __contains__zIndexes.__contains__6  s    dm##r-   r  c                    | j         |         S r&   r,  r  s     r*   r   zIndexes.__getitem__9  s    }S!!r-   c                *    t          j        |           S r&   )r   indexes_reprr:   s    r*   r=  zIndexes.__repr__<  s    &t,,,r-   )r/   r  r    r  )r$   r  )r$   r  )r$   r  )r$   r  )r$   r  )r$   r  )r$   r   )r  r   r$   rq   )r
  )r  r   r  r   r$   r  )r  r   r  r   r$   r  )r$   r  )r$   r  r   )rh   rq   rl   rm   r$   r  )r$   r%  )r$   r(  )r$   rq   )r$   r  )r   r   r   r   r?  r@  r   propertyr  r  r  r    r   rs   r  r	  r  r  r  r  r$  r'  r*  r-  r   r=  rA   r-   r*   r  r  L  s,          /...####IM M M M. $ $ $ X$
    X
 % % % X% ' ' ' X' " " " X"F F F F   G G G G 5<@ @ @ @ @@ 5<M M M M M.   1 1 1 1$ @D&+ &+ &+ &+ &+P# # # #" " " "$ $ $ $" " " "- - - - -r-   r  r#  r   r   dict[Hashable, Index]c                    i }t          |           }|                                 D ]P\  }}||v rGt          ||           \  }t          |          |k    r!|                    fd|D                        Q|S )ay  Default indexes for a Dataset/DataArray.

    Parameters
    ----------
    coords : Mapping[Any, xarray.Variable]
        Coordinate variables from which to draw default indexes.
    dims : iterable
        Iterable of dimension names.

    Returns
    -------
    Mapping from indexing keys (levels/dimension names) to indexes used for
    indexing along that dimension.
    c                    i | ]}|S rA   rA   )r   r}   r   s     r*   rg  z#default_indexes.<locals>.<dictcomp>X  s    ===Q5===r-   )r  rx   r  r{   )r#  r   r/   coord_namesr   r   r  r   s          @r*   default_indexesr6  @  s    " &(Gf++K\\^^ ? ?	c4<< =c6 J JE::+--====*===>>>Nr-   r  variableother_variablecache)dict[tuple[int, int], bool | None] | Nonerq   c                X   |i }t          |           t          |          f}d}||vrOt          |           t          |          u r.	 |                     |          }|||<   n# t          $ r d}Y nw xY wd}n||         }||                    |          }t	          t
          |          S )zCheck if two indexes are equal, possibly with cached results.

    If the two indexes are not of the same type or they do not implement
    equality, fallback to coordinate labels equality check.

    N)r  r   r\   r(   r   rq   )r   r  r7  r8  r9  r  rB  s          r*   indexes_equalr<  ]  s     }e99boo
&CE
%;;${++++#[11 #c

 '   
 EEc
}//es   A# #A21A2elements0Sequence[tuple[Index, dict[Hashable, Variable]]]c                X     fd}d  D             t          fddd         D                       }|rdS t          fddd         D                       }|r?	 t          fddd         D                       }n$# t          $ r  |            }Y nw xY w |            }| S )	zCheck if indexes are all equal.

    If they are not of the same type or they do not implement this check, check
    if their coordinate variables are all equal instead.

    c                 d     d D              t           fd dd          D                       S )Nc                    g | ]
}|d          S rF  rA   r   r)  s     r*   r	  z>indexes_all_equal.<locals>.check_variables.<locals>.<listcomp>  s    ,,,aQqT,,,r-   c              3  ~   K   | ]7}d          D ],}d          |                              ||                    V  -8dS r   Nr  )r   
other_varsr}   r    s      r*   r   z=indexes_all_equal.<locals>.check_variables.<locals>.<genexpr>  so       
 
q\
 
  !Q&&z!}555
 
 
 
 
 
 
r-   r   )r   )r    r=  s   @r*   check_variablesz*indexes_all_equal.<locals>.check_variables  sW    ,,8,,,	 
 
 
 
'm
 
 
 
 
 	
r-   c                    g | ]
}|d          S )r   rA   rB  s     r*   r	  z%indexes_all_equal.<locals>.<listcomp>  s    &&&qt&&&r-   c              3  ,   K   | ]}d          |u V  dS rD  rA   r   	other_idxr/   s     r*   r   z$indexes_all_equal.<locals>.<genexpr>  s,      LL9wqzY.LLLLLLr-   r   NTc              3  `   K   | ](}t          d                    t          |          u V  )dS rD  )r   rI  s     r*   r   z$indexes_all_equal.<locals>.<genexpr>  s:      UUID$$Y7UUUUUUr-   c              3  P   K   | ] }d                               |           V  !dS rD  r  rI  s     r*   r   z$indexes_all_equal.<locals>.<genexpr>  sI        5>GAJ%%i000     r-   )r
  r   r(   )r=  rF  same_objects	same_type	not_equalr/   s   `    @r*   indexes_all_equalrP    s'   
 
 
 
 
 '&X&&&GLLLLLLLLLL tUUUUQRQSQSUUUUUI &	*    BI!""+    II # 	* 	* 	*'))III	* $O%%	=s   !#B BBr/   Indexes[Index]argsMapping[Any, Any]func6tuple[dict[Hashable, Index], dict[Hashable, Variable]]c                  
 d |                                  D             }i }|                                 D ]\  }}d |                                D             

fd|                                 D             }|r t          ||          |          L|                    fd|D                                            |          }|                    |           |D ]}	|                    |	d            ||fS )Nc                    i | ]\  }}||	S rA   rA   rN  s      r*   rg  z"_apply_indexes.<locals>.<dictcomp>  s    )K)K)K41a!Q)K)K)Kr-   c                &    h | ]}|j         D ]}|S rA   rI  )r   r   ds      r*   r  z!_apply_indexes.<locals>.<setcomp>  s'    IIICII1aIIIIr-   c                $    i | ]\  }}|v 	||S rA   rA   )r   r}   r~   
index_dimss      r*   rg  z"_apply_indexes.<locals>.<dictcomp>  s$    GGGtq!qJar-   c                    i | ]}|S rA   rA   r  s     r*   rg  z"_apply_indexes.<locals>.<dictcomp>  s    #E#E#EQAy#E#E#Er-   )rx   r  r   r   r{   rC   pop)r/   rR  rT  r  new_index_variablesr   r  
index_argsr!  r}   r[  r  s             @@r*   _apply_indexesr`    s5   
 *L)K7==??)K)K)KK46$3355 - -zII:#4#4#6#6III
GGGGtzz||GGG
 	-,t,,Z88I$""#E#E#E#E*#E#E#EFFF!*!;!;J!G!G#**>::::# - -AOOAt,,,,+++r-   rH   c                $    t          | |d          S )NrL   r`  )r/   rH   s     r*   isel_indexesrc    s     '8V444r-   r]   r^   c                $    t          | |d          S )Nr`   rb  )r/   r]   s     r*   roll_indexesre    s     '66222r-   Mapping[Any, Index]filtered_coord_namesr  c                   t          |           }t          t                    }|                                 D ]-\  }}|t	          |                                       |           .|                                D ]}||k    s|D ]}||= |S )zFilter index items given a (sub)set of coordinate names.

    Drop all multi-coordinate related index items for any key missing in the set
    of coordinate names.

    )rB   r   r  rx   r  r  r   )r/   rg  filtered_indexesindex_coord_namesr   r  idx_coord_namesr}   s           r*   filter_indexes_from_coordsrl    s     *.g7B37G7G]]__ - -	c"S''"&&t,,,,,3355 ( ("666$ ( ($Q''r-   remove coordinate(s)r5  set[Hashable]actionNonec                T   |                                  D ]\  }}t          |          |z  }|ryt          |          t          |          k    rYd                    d |D                       }d                    d |D                       }t	          d| d| d| d|           dS )	z@Assert removing coordinates or indexes will not corrupt indexes.rJ  c              3     K   | ]}|V  d S r&   rA   r  s     r*   r   z,assert_no_index_corrupted.<locals>.<genexpr>  s$      (H(HaA(H(H(H(H(H(Hr-   c              3     K   | ]}|V  d S r&   rA   r  s     r*   r   z,assert_no_index_corrupted.<locals>.<genexpr>  s$      'G'GQ1'G'G'G'G'G'Gr-   zcannot rM  zA, which would corrupt the following index built from coordinates z:
N)r  r  r   rV   r   )r/   r5  ro  r   r  common_namescommon_names_strindex_names_strs           r*   assert_no_index_corruptedrw    s      '5577 	 	|<((;6 	C--\1B1BBB#yy(H(H<(H(H(HHH"ii'G'G,'G'G'GGGO&  #3  >M    	 	r-   )r   rD   r$   rD   )r   r   r$   rD   )r   NNr&   )r$   r   )r   r   r>  )rB  )r    r!   rC  rT   )r  r   r  r  r$   r  )r#  r!   r   r   r$   r2  )r   r   r  r   r7  r   r8  r   r9  r:  r$   rq   )r=  r>  r$   rq   )r/   rQ  rR  rS  rT  rT   r$   rU  )r/   rQ  rH   rS  r$   rU  )r/   rQ  r]   r^   r$   rU  )r/   rf  rg  r  r$   r2  )rm  )r/   rQ  r5  rn  ro  rT   r$   rp  )E
__future__r   collections.abccollectionsrs   r   r   r   r   r   r	   typingr
   r   r   r   r   numpyr   pandasr   xarray.corer   r   r   xarray.core.indexingr   r   r   xarray.core.utilsr   r   r   r   r   xarray.core.typesr   r   r   r   rB   r?   r   r   r   r   r   r   r   r   r   r   r   r   rR  r`  rb  r  r  abcr  r6  r<  rP  r`  rc  re  rl  rw  rA   r-   r*   <module>r     sD   " " " " " "      # # # # # # K K K K K K K K K K K K K K = = = = = = = = = = = = = =         2 2 2 2 2 2 2 2 2 2         
               .77777777------j!	i' i' i' i' i' i' i' i'X	 	 	 	'- '- '- '-T  $   *  $  	 	 	 	 	C C C C
	 	 	 	 }===V2 V2 V2 V2 V2% V2 V2 V2r
 
 
 
 
.   6e
 e
 e
 e
 e
{ e
 e
 e
T :>0 0 0 0 0h   7II q- q- q- q- q-ko%w/D'E q- q- q-h   D 8<$ $ $ $ $N# # # #L, , , ,05 5 5 53 3 3 3   6 )      r-   