U Cv f @sddlmZddlZddlZddlZddlmZmZddlm Z ddl m Z m Z ddl mZddlmZddlmZmZmZmZmZmZddlZddlZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/er.ddl0m1Z1ddl2m3Z3ddl4m5Z5e GdddZ6dddddZ7dddddddZ8dddd dd!d"d#Z9d$d%Z:d&d'Z;d(d)ZGd.d/d/Z?d0d1Z@d2d3ZAGd4d5d5e?ZBGd6d7d7e?ZCGd8d9d9e?ZDGd:d;d;ZEGdd?d?e,ZGGd@dAdAeFZHeHZIGdBdCdCeFZJdDdEZKGdFdGdGeFZLGdHdIdIeFZMdJdKZNdLdMZOdNdOZPdPdQZQejRGdRdSdSejSZTd/dTdSdUd dVdWdXZUd/dTdSdYdZd[d\ZVd]d^ZWd9dTdSdYdZd_d`ZXdadTdSdYdZdbdcZYdddeZZdfdgZ[dhdiZ\ddjdkZ]ddldmZ^dndoZ_dpdqZ`d drdsdtduZaGdvdwdweFZbGdxdydyebZcGdzd{d{eFZdGd|d}d}eFZeGd~ddeFZfGdddefZgdS)) annotationsN)Counter defaultdict)suppress) dataclassfield) timedelta)escape) TYPE_CHECKINGAnyCallableHashableIterableMapping)Version)duck_array_ops)NumpyVIndexAdapter)OPTIONS) array_type integer_typesis_duck_dask_array mod_version)T_Xarray) NDArrayMixineither_dict_or_kwargsget_valid_numpy_dtype to_0d_array) DTypeLike)Index)Variablec@s|eZdZUdZded<eedZded<eedZded<ee dZ d ed <ee dZ d ed <eedZ d ed <ddZ dS)IndexSelResultaIndex query results. Attributes ---------- dim_indexers: dict A dictionary where keys are array dimensions and values are location-based indexers. indexes: dict, optional New indexes to replace in the resulting DataArray or Dataset. variables : dict, optional New variables to replace in the resulting DataArray or Dataset. drop_coords : list, optional Coordinate(s) to drop in the resulting DataArray or Dataset. drop_indexes : list, optional Index(es) to drop in the resulting DataArray or Dataset. rename_dims : dict, optional A dictionary in the form ``{old_dim: new_dim}`` for dimension(s) to rename in the resulting DataArray or Dataset. zdict[Any, Any] dim_indexers)default_factoryzdict[Any, Index]indexeszdict[Any, Variable] variableszlist[Hashable] drop_coords drop_indexeszdict[Any, Hashable] rename_dimscCs|j|j|j|j|j|jfS)zrUnlike ``dataclasses.astuple``, return a shallow copy. See https://stackoverflow.com/a/51802661 )r!r#r$r%r&r'selfr*8/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/indexing.pyas_tupleGszIndexSelResult.as_tupleN)__name__ __module__ __qualname____doc____annotations__rdictr#r$listr%r&r'r,r*r*r*r+r )s r zlist[IndexSelResult])resultsreturnc Cstdd|D}dd|D}|rPdd|D}tdd|di}i}i}g}g}i} |D]H} || j|| j|| j|| j7}|| j 7}| | j qlt |||||| S) NcSsg|]}|jD]}|qqSr*r!).0resdimr*r*r+ Xsz%merge_sel_results..cSsi|]\}}|dkr||qSr*)r7kvr*r*r+ Ysz%merge_sel_results..cSs g|]\}}|d|dqS): z indexes involvedr*)r7r9countr*r*r+r:^szhXarray does not support label-based selection with more than one index over the following dimension(s):  z> Suggestion: use a multi-index for each of those dimension(s).) ritems ValueErrorjoinupdater!r#r$r%r&r'r ) r4Zall_dims_countZduplicate_dimsZfmt_dimsr!r#r$r%r&r'r8r*r*r+merge_sel_resultsWsD     rGrzMapping[Any, Any]zMapping[str, Any]z"list[tuple[Index, dict[Any, Any]]])objindexersoptionsr5csitt|D]\}}|j|d}|dk rPt|}||<|||<q||jkrjtd|q||jkrt|dqt |rt d|d|dqdd<|d|<qfddDS) zBReturns a list of unique indexes and their corresponding indexers.Nzno index found for coordinate z' is not a valid dimension or coordinatez cannot supply selection options z for dimension z*that has no associated coordinate or indexcsg|]}||fqSr*r*r7r=grouped_indexersZunique_indexesr*r+r:sz+group_indexers_by_index..) rr2rCZxindexesgetidZcoordsKeyErrorZdimslenrD)rHrIrJkeylabelindexZindex_idr*rLr+group_indexers_by_index}s&  rUr )rHrIindexers_kwargsr5c sddlm}|dkr"|dkr"i}n ||d}t||d}t|||}g}|D]4\} } | dkrl|t| qL|| j| f|qLt|j D]J\} } t | |r| | j kr| | } fdd| j D} | | j| <qS)zzExecute index queries from a DataArray / Dataset and label-based indexers and return the (merged) query results. r) DataArrayN)method tolerancemap_index_queriescsg|]}|jkr|qSr*r6)r7namemergedr*r+r:s z%map_index_queries..)Zxarray.core.dataarrayrWrrUappendr selrGr!rC isinstanceZ_indexesZ reset_indexZ_coordsZ drop_vars)rHrIrXrYrVrWrJrMr4rTlabelsr=r>r%r*r\r+rZs&        rZcCst|ts|f}g}d}|D]P}|tkrb|sR||dt|tdgd}ql|tdq||qt||krtd||t|tdgt|S)aMGiven a key for indexing an ndarray, return an equivalent key which is a tuple with length equal to the number of dimensions. The expansion is done by replacing all `Ellipsis` items with the right number of full slices and then padding the key with full slices so that it reaches the appropriate dimensionality. Fr<NTztoo many indices)r`tupleEllipsisextendrQslicer^ IndexError)rRndimnew_keyZfound_ellipsisr=r*r*r+expanded_indexers    ricCstj||SN)nparangeindices)Zslice_sizer*r*r+ _expand_slicesrocCst||S)zEnsure that given slice only contains positive start and stop values (stop can be -1 for full-size slices with negative steps, e.g. [-10::-1]))rerm)slrnr*r*r+_normalize_slicesrqcCst||}tt|j|j|j}|dkr0tdSt||}|j|j|j}|dkr\tdS|j|j|j}|dkrzd}|j|j}t|||S)zGiven a slice and the size of the dimension to which it will be applied, index it with another slice to return a new slice equivalent to applying the slices sequentially rN)rqrQrangestartstopstepre)Z old_sliceZ applied_slicernZsize_after_old_slicersrtrur*r*r+ slice_slices   rvcCspt|tttjfstt|tr2|tdkr2|St|trdt|trTt|||}qlt|||}n||}|Srj)r`rrerkndarrayAssertionErrorrvro)Z old_indexerZapplied_indexerrnindexerr*r*r+_index_indexer_1ds  rzc@s0eZdZdZdZddZeddZddZd S) ExplicitIndexerazBase class for explicit indexer objects. ExplicitIndexer objects wrap a tuple of values given by their ``tuple`` property. These tuples should always have length equal to the number of dimensions on the indexed array. Do not instantiate BaseIndexer objects directly: instead, use one of the sub-classes BasicIndexer, OuterIndexer or VectorizedIndexer. _keycCs"t|tkrtdt||_dS)Nz/cannot instantiate base ExplicitIndexer objects)typer{ TypeErrorrbr}r)rRr*r*r+__init__.s zExplicitIndexer.__init__cCs|jSrjr|r(r*r*r+rb3szExplicitIndexer.tuplecCst|jd|jdS)N())r~r-rbr(r*r*r+__repr__7szExplicitIndexer.__repr__N) r-r.r/r0 __slots__rpropertyrbrr*r*r*r+r{!s   r{cCs|dkr dSt|Srj)operatorrT)valuer*r*r+as_integer_or_none;srcCs*t|j}t|j}t|j}t|||Srj)rrsrtrure)rrsrtrur*r*r+as_integer_slice?s   rcs$eZdZdZdZfddZZS) BasicIndexerzTuple for basic indexing. All elements should be int or slice objects. Indexing follows NumPy's rules for basic indexing: each axis is independently sliced and axes indexed with an integer are dropped from the result. r*cst|tstd|g}|D]P}t|tr8t|}n.t|trLt|}ntdt|jd|| |q t |dS)Nkey must be a tuple: unexpected indexer type for r@) r`rbrrintrerr~r-r^superrr)rRrhr= __class__r*r+rPs      zBasicIndexer.__init__r-r.r/r0rr __classcell__r*r*rr+rFsrcs$eZdZdZdZfddZZS) OuterIndexera9Tuple for outer/orthogonal indexing. All elements should be int, slice or 1-dimensional np.ndarray objects with an integer dtype. Indexing is applied independently along each axis, and axes indexed with an integer are dropped from the result. This type of indexing works like MATLAB/Fortran. r*cst|tstd|g}|D]}t|tr8t|}nt|trLt|}nzt|tjrt |j tj svtd||j dkrtdt |jd|tj|tjd}ntdt |jd|||q t|dS) Nr4invalid indexer array, does not have integer dtype: r<zinvalid indexer array for z!; must have exactly 1 dimension: dtyperr@)r`rbrrrrerrkrw issubdtyperintegerrgr~r-asarrayint64r^rrrrr*r+rns.        zOuterIndexer.__init__rr*r*rr+rcsrcs$eZdZdZdZfddZZS)VectorizedIndexeraTuple for vectorized indexing. All elements should be slice or N-dimensional np.ndarray objects with an integer dtype and the same number of dimensions. Indexing follows proposed rules for np.ndarray.vindex, which matches NumPy's advanced indexing rules (including broadcasting) except sliced axes are always moved to the end: https://github.com/numpy/numpy/pull/6256 r*cst|tstd|g}d}|D]}t|tr.zMinvalid indexer key: ndarray arguments have different numbers of dimensions: rrr@)r`rbrrerrkrwrrrrgrDrrr~r-r^rr)r)rRrhrgr=Zndimsrr*r+rs2      zVectorizedIndexer.__init__rr*r*rr+rs rc@seZdZdZdZdS)ExplicitlyIndexedz9Mixin to mark support for Indexer subclasses in indexing.r*N)r-r.r/r0rr*r*r*r+rsrc@seZdZdZdddZdS)ExplicitlyIndexedNDArrayMixinr*NcCs&ttdf|j}tj|||dSNr)rrergrkr)r)rrRr*r*r+ __array__sz'ExplicitlyIndexedNDArrayMixin.__array__)N)r-r.r/rrr*r*r*r+rsrc@s2eZdZdZdZefddZd ddZdd ZdS) !ImplicitToExplicitIndexingAdapterzEWrap an array, converting tuples into the indicated explicit indexer.)array indexer_clscCst||_||_dSrj) as_indexablerr)r)rrr*r*r+rs z*ImplicitToExplicitIndexingAdapter.__init__NcCstj|j|dSrrkrrr)rr*r*r+rsz+ImplicitToExplicitIndexingAdapter.__array__cCs>t||j}|j||}t|tr6t|||jS|SdSrj)rirgrrr`rr~)r)rRresultr*r*r+ __getitem__s   z-ImplicitToExplicitIndexingAdapter.__getitem__)N) r-r.r/r0rrrrrr*r*r*r+rs   rc@sbeZdZdZdZdddZddZedd d d Zdd d Z ddZ ddZ ddZ ddZ dS)LazilyIndexedArrayz4Wrap an array to make basic and outer indexing lazy.rrRNcCsRt|t|r"|dkr"|j}|j}|dkr>ttdf|j}t||_||_dS)a Parameters ---------- array : array_like Array like object to index. key : ExplicitIndexer, optional Array indexer. If provided, it is assumed to already be in canonical expanded form. N)r`r~rRrrrergrr)rrRr*r*r+rs  zLazilyIndexedArray.__init__cCstt|j|j}g}t|jj|jjD]4\}}t|t rF| |q(| t |t ||q(t|}t dd|Drt|St|S)Ncss|]}t|ttfVqdSrj)r`rrerKr*r*r+ sz2LazilyIndexedArray._updated_key..)iterrirbrgziprshaperRr`rr^rznextallrr)r)rhZ iter_new_keyfull_keyrnr=r*r*r+ _updated_keys  zLazilyIndexedArray._updated_keytuple[int, ...]r5cCsdg}t|jj|jjD]D\}}t|trB|tt | |qt|t j r||j qt|Srj)rrrrRrbr`rer^rQrrrmrkrwrn)r)rrnr=r*r*r+rs  zLazilyIndexedArray.shapecCst|j}tj||jddSr)rrrkrrRr)rrr*r*r+rs zLazilyIndexedArray.__array__cCst|j|j|Srj)LazilyVectorizedIndexedArrayrrR transposer)orderr*r*r+rszLazilyIndexedArray.transposecCs6t|tr t|j|j}||St||j||Srj)r`rrrrRr~r)r)ryrr*r*r+rs zLazilyIndexedArray.__getitem__cCs*t|trtd||}||j|<dSNzvLazy item assignment with the vectorized indexer is not yet implemented. Load your data first by .load() or compute().)r`rNotImplementedErrorrr)r)rRrrr*r*r+ __setitem__s   zLazilyIndexedArray.__setitem__cCs t|jd|jd|jdSN(array=z, key=rr~r-rrRr(r*r*r+r%szLazilyIndexedArray.__repr__)N)N)r-r.r/r0rrrrrrrrrrr*r*r*r+rs   rc@s`eZdZdZdZddZeddddZdd d Zd d Z ddZ ddZ ddZ ddZ d S)rz/Wrap an array to make vectorized indexing lazy.rcCs:t|ttfrt||j|_nt||j|_t||_dS)z Parameters ---------- array : array_like Array like object to index. key : VectorizedIndexer N) r`rr_outer_to_vectorized_indexerrrR_arrayize_vectorized_indexerrrrr*r*r+r2sz%LazilyVectorizedIndexedArray.__init__rrcCstj|jjjSrj)rk broadcastrRrbrr(r*r*r+r@sz"LazilyVectorizedIndexedArray.shapeNcCstj|j|jddSr)rkrrrRrr*r*r+rDsz&LazilyVectorizedIndexedArray.__array__cCst|j|j|Srj)_combine_indexersrRr)r)rhr*r*r+rGsz)LazilyVectorizedIndexedArray._updated_keycsTtddjDr>ttfdd|jjD}t|j|St||j|S)Ncss|]}t|tVqdSrjr`r)r7indr*r*r+rLsz;LazilyVectorizedIndexedArray.__getitem__..c3s|]}|jVqdSrjrbrKryr*r+rMs)rrbrrRrrr~r)r)ryrRr*rr+rJs z(LazilyVectorizedIndexedArray.__getitem__cs.ttfdd|jjD}t||j|S)Nc3s|]}|VqdSrj)rrKrr*r+rRsz9LazilyVectorizedIndexedArray.transpose..)rrbrRr~r)r)rrRr*rr+rQsz&LazilyVectorizedIndexedArray.transposecCs tddSr)rr)rRrr*r*r+rUsz(LazilyVectorizedIndexedArray.__setitem__cCs t|jd|jd|jdSrrr(r*r*r+r[sz%LazilyVectorizedIndexedArray.__repr__)N)r-r.r/r0rrrrrrrrrrr*r*r*r+r-s rcCst|rt|S|SdS)z Wrap NumPy scalars in 0d arrays.N)rkZisscalarrrr*r*r+_wrap_numpy_scalars_s  rc@sJeZdZdZddZddZdddZd d Zd d Zd dZ ddZ dS)CopyOnWriteArray)r_copiedcCst||_d|_dS)NF)rrrr)rr*r*r+rjs zCopyOnWriteArray.__init__cCs"|jstt|j|_d|_dS)NT)rrrkrr(r*r*r+_ensure_copiednszCopyOnWriteArray._ensure_copiedNcCstj|j|dSrrrr*r*r+rsszCopyOnWriteArray.__array__cCst|t|j|Srjr~rrrr*r*r+rvszCopyOnWriteArray.__getitem__cCs |j|Srjrrrr*r*r+ryszCopyOnWriteArray.transposecCs|||j|<dSrj)rrrr*r*r+r|szCopyOnWriteArray.__setitem__cCst||jSrj)r~r)r)memor*r*r+ __deepcopy__szCopyOnWriteArray.__deepcopy__)N) r-r.r/rrrrrrrrr*r*r*r+rgs rc@sBeZdZdZddZddZdddZd d Zd d Zd dZ dS)MemoryCachedArrayrcCstt||_dSrj)rrrrr*r*r+rszMemoryCachedArray.__init__cCs"t|jtstt|j|_dSrj)r`rNumpyIndexingAdapterrkrr(r*r*r+_ensure_cacheds z MemoryCachedArray._ensure_cachedNcCs|tj|j|dSr)rrkrrrr*r*r+rszMemoryCachedArray.__array__cCst|t|j|Srjrrr*r*r+rszMemoryCachedArray.__getitem__cCs |j|Srjrrr*r*r+rszMemoryCachedArray.transposecCs||j|<dSrjrrr*r*r+rszMemoryCachedArray.__setitem__)N) r-r.r/rrrrrrrr*r*r*r+rs rcCst|tr|St|tjr"t|St|tjr6t|St|rFt |St |drXt |St |drjt |St dt|dS)z This function always returns a ExplicitlyIndexed subclass, so that the vectorized indexing is always possible with the returned object. __array_function____array_namespace__zInvalid array type: N)r`rrkrwrpdrPandasIndexingAdapterrDaskIndexingAdapterhasattrNdArrayLikeIndexingAdapterArrayApiIndexingAdapterrr~rr*r*r+rs     rcCs|j}tdd|D}d}g}t||D]\}}t|trX|t|d|q*t|t rrtj | |}|j j dkstd||jfd||dg}||j||d7}q*tt|S)aConvert an OuterIndexer into an vectorized indexer. Parameters ---------- key : Outer/Basic Indexer An indexer to convert. shape : tuple Shape of the array subject to the indexing. Returns ------- VectorizedIndexer Tuple suitable for use to index a NumPy array with vectorized indexing. Each element is an array: broadcasting them together gives the shape of the result. cSsg|]}t|ts|qSr*rrKr*r*r+r:s z0_outer_to_vectorized_indexer..rr;>iur<)rbrQrr`rr^rkrreshapererlrmrkindrxrnr)rRrn_dimi_dimrhr=rnr*r*r+rs  " rcCs.tdd|jDdkr|jSt||jSdS)a2Convert an OuterIndexer into an indexer for NumPy. Parameters ---------- key : Basic/OuterIndexer An indexer to convert. shape : tuple Shape of the array subject to the indexing. Returns ------- tuple Tuple suitable for use to index a NumPy array. cSsg|]}t|ts|qSr*r`rerKr*r*r+r:s z+_outer_to_numpy_indexer..r<N)rQrbr)rRrr*r*r+_outer_to_numpy_indexersrcsvt|tst||}t|jdkr&Stj|jj}ttrJt|n t|ttfddtj |jDS)a%Combine two indexers. Parameters ---------- old_key : ExplicitIndexer The first indexer for the original array shape : tuple of ints Shape of the original array to be indexed by old_key new_key The second indexer for indexing original[old_key] rc3s|]}|jVqdSrjr)r7orhr*r+rsz$_combine_indexers..) r`rrrQrbrkrrrZbroadcast_arrays)Zold_keyrrhZ new_shaper*rr+rs     rc@seZdZdZdZdZdZdS)IndexingSupportrr<N)r-r.r/BASICOUTER OUTER_1VECTOR VECTORIZEDr*r*r*r+r srrr )rRrindexing_supportraw_indexing_methodr5cCs6t|||\}}||j}|jr2tt||}|S)aSupport explicit indexing by delegating to a raw indexing method. Outer and/or vectorized indexers are supported by indexing a second time with a NumPy array. Parameters ---------- key : ExplicitIndexer Explicit indexing object. shape : Tuple[int, ...] Shape of the indexed array. indexing_support : IndexingSupport enum Form of indexing supported by raw_indexing_method. raw_indexing_method : callable Function (like ndarray.__getitem__) that when called with indexing key in the form of a tuple returns an indexed array. Returns ------- Indexing result, in the form of a duck numpy-array. )decompose_indexerrbrrkr)rRrrrZraw_keyZ numpy_indicesrr*r*r+explicit_indexing_adapters  rz'tuple[ExplicitIndexer, ExplicitIndexer])ryrrr5cCsBt|trt|||St|ttfr0t|||Std|dSNunexpected key type: )r`r_decompose_vectorized_indexerrr_decompose_outer_indexerr)ryrrr*r*r+r;s    rcCst||\}}}|dkr$|tdfS|t||d||d}|d|d}}t||| tdddfSdS)z^convert a slice to successive two slices. The first slice always has a positive step. rNr<)rmrer)rRrnrsrtrur*r*r+_decompose_sliceEs   rcCst|tst|tjkr$|tdfSg}g}ddt|j|D}t||D]d\}}t|trt ||\}} | || | qLt j |dd\} } | | | | j |jqLtt|} tt|} |tjkr| | fSt| ||\}}t||| } || fS)a: Decompose vectorized indexer to the successive two indexers, where the first indexer will be used to index backend arrays, while the second one is used to index loaded on-memory np.ndarray. Parameters ---------- indexer : VectorizedIndexer indexing_support : one of IndexerSupport entries Returns ------- backend_indexer: OuterIndexer or BasicIndexer np_indexers: an ExplicitIndexer (VectorizedIndexer / BasicIndexer) Notes ----- This function is used to realize the vectorized indexing for the backend arrays that only support basic or outer indexing. As an example, let us consider to index a few elements from a backend array with a vectorized indexer ([0, 3, 1], [2, 3, 2]). Even if the backend array only supports outer indexing, it is more efficient to load a subslice of the array than loading the entire array, >>> array = np.arange(36).reshape(6, 6) >>> backend_indexer = OuterIndexer((np.array([0, 1, 3]), np.array([2, 3]))) >>> # load subslice of the array ... array = NumpyIndexingAdapter(array)[backend_indexer] >>> np_indexer = VectorizedIndexer((np.array([0, 2, 1]), np.array([0, 1, 0]))) >>> # vectorized indexing for on-memory np.ndarray. ... NumpyIndexingAdapter(array)[np_indexer] array([ 2, 21, 8]) r*cSs6g|].\}}t|tjr.t|dk|||n|qS)r)r`rkrwwhere)r7r=sr*r*r+r:sz1_decompose_vectorized_indexer..TZreturn_inverse)r`rrxrrrrrbrerr^rkuniquerrrrrr)ryrrZbackend_indexer_elemsZnp_indexer_elems indexer_elemsr=rbk_slicenp_sliceoindvindbackend_indexer np_indexerZbackend_indexer1Z np_indexer1r*r*r+rUs6'           rzBasicIndexer | OuterIndexercCsx|tjkr|tdfSt|ttfs(tg}g}g}t|j|D]^\}}t|tj rr| t |dk|||q@t|t r|dkr| ||q@| |q@|}|tj krdd|D} t| dkrtt| nd} tt||D]\} \}}t|tj rF| | krF| tt|t|d| |t|qt|tj r|tj|dd\} } | | | | qt|t r| |qt||\}}| || |qtt|tt|fS|tjkrt||D]\}}t|trt||\}}| || |nt|t r6| |njt|tj rrt|dkrr| || tdn.tj|dd\}}| || |j|jqtt|tt|fS|tjkstt||D]\}}t|tj r"| tt|t|d| |t|n:t|t r:| |n"t||\}}| || |qtt|tt|fS) ad Decompose outer indexer to the successive two indexers, where the first indexer will be used to index backend arrays, while the second one is used to index the loaded on-memory np.ndarray. Parameters ---------- indexer : OuterIndexer or BasicIndexer indexing_support : One of the entries of IndexingSupport Returns ------- backend_indexer: OuterIndexer or BasicIndexer np_indexers: an ExplicitIndexer (OuterIndexer / BasicIndexer) Notes ----- This function is used to realize the vectorized indexing for the backend arrays that only support basic or outer indexing. As an example, let us consider to index a few elements from a backend array with a orthogonal indexer ([0, 3, 1], [2, 3, 2]). Even if the backend array only supports basic indexing, it is more efficient to load a subslice of the array than loading the entire array, >>> array = np.arange(36).reshape(6, 6) >>> backend_indexer = BasicIndexer((slice(0, 3), slice(2, 4))) >>> # load subslice of the array ... array = NumpyIndexingAdapter(array)[backend_indexer] >>> np_indexer = OuterIndexer((np.array([0, 2, 1]), np.array([0, 1, 0]))) >>> # outer indexing for on-memory np.ndarray. ... NumpyIndexingAdapter(array)[np_indexer] array([[ 2, 3, 2], [14, 15, 14], [ 8, 9, 8]]) r*rcSsBg|]:}t|tjr:t|t|dtt|ndqS)g?r)r`rkrwmaxminrQrrKr*r*r+r:s (z,_decompose_outer_indexer..Nr<Tr)rrrr`rrxrrbrkrwr^rrrrQZargmaxr enumeratererrrrrZdiffrrrr)ryrrrrZ pos_indexerr=rrZgainsZ array_indexrZpkeyZekeyrrrrr*r*r+rst)                   "      rc Csdd|jD}t|dkr |Sdd|jD}t|dkrF|djnd}d}g}t|j|D]~\}}t|tjr|t||j dt|q^d||ddt||d}|tj | |||d7}q^t t|S)zr*r*r+r:)s z0_arrayize_vectorized_indexer..rcSsg|]}t|tjr|qSr*)r`rkrwr r*r*r+r:-s r;)rr<) rbrQrgrr`rkrwr^rrrlrmr) ryrZslicesZarraysrrrhr>rnr*r*r+r's  "$ rcCs^ddlm}t||jkr"tdg}t||jD]\}}||dkrJ|ndq2|||S)zECreate a dask array using the chunks hint for dimensions of size > 1.rNznot enough chunks in hintr<r;) Z dask.arrayrrQrgrDrrr^Z from_array)rchunksdaZ new_chunkschunkrnr*r*r+_dask_array_with_chunks_hint;s rcCsttj|Srj) functoolsreduceror_)argsr*r*r+ _logical_anyGsrcCsdd|D}t|dd}g}|D]j}t|tjrt|rL|t||qt|tdrvddl}||j |q||q"||q"t dd|D}|S)Ncss|]}t|ts|VqdSrjrrKr*r*r+rMs z,_masked_result_drop_slice..r sparsercss|]}|dkVqdSrNr*rKr*r*r+r^s) getattrr`rkrwrr^rrrZCOOZ from_numpyr)rRdataZ chunks_hintZnew_keysr=rmaskr*r*r+_masked_result_drop_sliceKs    rcCst|tr8t||j}tdd|Dr,tt||}nt|tr|j}t||}tddt||D}|t ft j ft |}t ||j|}n2t|trtdd|jD}ntdt||S)aCreate a mask for indexing with a fill-value. Parameters ---------- indexer : ExplicitIndexer Indexer with -1 in integer or ndarray value to indicate locations in the result that should be masked. shape : tuple Shape of the array being indexed. data : optional Data for which mask is being created. If data is a dask arrays, its chunks are used as a hint for chunks on the resulting mask. If data is a sparse array, the returned mask is also a sparse array. Returns ------- mask : bool, np.ndarray, SparseArray or dask.array.Array with dtype=bool Same type as data. Has the same shape as the indexing result. css|]}t|tVqdSrjrrKr*r*r+rxszcreate_mask..css.|]&\}}t|trtj||jVqdSrj)r`rerkrlrmrn)r7r=rnr*r*r+r~s css|]}|dkVqdSrr*rKr*r*r+rsr)r`rrrbanyrxrrrrcrkZnewaxisrQrZ broadcast_torrrr~)ryrrrRrZ base_maskZ slice_shapeZ expanded_maskr*r*r+ create_maskbs       rcCsb|dk}t|}|js$t|St|}tdt||d}|}|||||<|S)aHConvert masked indices in a flat array to the nearest unmasked index. Parameters ---------- index : np.ndarray One dimensional ndarray with dtype=int. Returns ------- np.ndarray One dimensional ndarray with all values equal to -1 replaced by an adjacent non-masked element. rrr<)rkZ flatnonzerornZ zeros_likemaximumZ searchsortedcopy)rTZmaskedZ unmasked_locsZ masked_locsZ prev_valueZ new_indexr*r*r+_posify_mask_subindexers   rcCs tdd|jD}t||S)aConvert masked values (-1) in an indexer to nearest unmasked values. This routine is useful for dask, where it can be much faster to index adjacent points than arbitrary points from the end of an array. Parameters ---------- indexer : ExplicitIndexer Input indexer. Returns ------- ExplicitIndexer Same type of input, with all values in ndarray keys equal to -1 replaced by an adjacent non-masked element. css2|]*}t|tjr&t||jn|VqdSrj)r`rkrwrZravelrrrKr*r*r+rs z&posify_mask_indexer..)rbr~)ryrRr*r*r+posify_mask_indexersrbool)ryr5cCsNt|ttfrdSt|tjr(|jdkSt|trJt|oHt|dt SdS)zReturn False if indexer is a int, slice, a 1-dimensional list, or a 0 or 1-dimensional ndarray; in all other cases return True Fr<rT)r`rrerkrwrgr3r rr*r*r+is_fancy_indexers   r!c@s<eZdZdZdZddZddZddZd d Zd d Z d S)rz,Wrap a NumPy array to use explicit indexing.rcCs(t|tjstdt|||_dS)Nz=NumpyIndexingAdapter only wraps np.ndarray. Trying to wrap {})r`rkrwrformatr~rrr*r*r+rs zNumpyIndexingAdapter.__init__cCstt|tr |j}t||jj}nLt|tr.r<z@xarray can't set arrays with multiple array indices to dask yet.aThis variable's data is stored in a dask array, and the installed dask version does not support item assignment. To assign to this variable, you must either upgrade dask orfirst load the variable into memory explicitly using the .load() method or accessing its .values attribute.) rrr`rrrbrr,rsumrr)r)rRrZnum_non_slicesr*r*r+rls"   zDaskIndexingAdapter.__setitem__cCs |j|Srjrrr*r*r+rszDaskIndexingAdapter.transposeNr+r*r*r*r+r=s $rc@seZdZdZdZd#dddddZed d d d Zd$dd dddZedd ddZ ddZ dd ddZ dd ddZ dd ddZ d%ddd d!d"ZdS)&rzDWrap a pandas.Index to preserve dtypes and handle explicit indexing.)r_dtypeNzpd.Indexr)rrcCs:ddlm}|||_|dkr*t||_n t||_dS)Nr)safe_cast_to_index)xarray.core.indexesr/rrr.rkr)r)rrr/r*r*r+rs    zPandasIndexingAdapter.__init__znp.dtypercCs|jSrj)r.r(r*r*r+rszPandasIndexingAdapter.dtype np.ndarrayrr5c CsN|dkr|j}|j}t|tjr>tt|d}W5QRXtj |j |dS)Nobjectr) rrr`rZ PeriodIndexrAttributeErrorZastyperkrvaluesrr*r*r+rs  zPandasIndexingAdapter.__array__rcCs t|jfSrj)rQrr(r*r*r+rszPandasIndexingAdapter.shapecCsv|tjkrtdd}nVt|tr8tt|d|d}n6t|tjrTt | }n|j t krntj ||j d}t |S)NNaTnsrr)rr6rkZ datetime64r`rZ timedelta64rZ TimestamprZ to_datetime64rr3r)r)itemr*r*r+_convert_scalars    z%PandasIndexingAdapter._convert_scalarzZPandasIndexingAdapter | NumpyIndexingAdapter | np.ndarray | np.datetime64 | np.timedelta64cCsz|j}t|tr"t|dkr"|\}t|dddkrDtt||S|j|}t|tj rlt |||j dS| |SdS)Nr<rgrr) rbr`rQrrrkrrrrr~rr9)r)ryrRrr*r*r+rs   z!PandasIndexingAdapter.__getitem__cCs|jSrjrrr*r*r+rszPandasIndexingAdapter.transposestrcCs t|jd|jd|jdS)Nr, dtype=r)r~r-rrr(r*r*r+rszPandasIndexingAdapter.__repr__Tr deepr5cCs(|r|jjddn|j}t|||jSNT)r=)rrr~r.r)r=rr*r*r+rszPandasIndexingAdapter.copy)N)N)T)r-r.r/r0rrrrrrr9rrrrr*r*r*r+rs  rcseZdZdZdZd#ddddfdd Zd$dd d fd d ZfddZfddZddfdd Z d dddZ dddddZ ddddZ d%ddd d!d"Z ZS)&PandasMultiIndexingAdapterzHandles explicit indexing for a pandas.MultiIndex. This allows creating one instance for each multi-index level while preserving indexing efficiency (memoized + might reuse another instance with the same multi-index). )rr.leveladapterNz pd.MultiIndexrz str | None)rrrAcst||||_dSrj)rrrA)r)rrrArr*r+rsz#PandasMultiIndexingAdapter.__init__r1r2csB|dkr|j}|jdk r2tj|j|jj|dSt|SdSr) rrArkrrZget_level_valuesr5rrrrr*r+rs z$PandasMultiIndexingAdapter.__array__cs<t|tr0|jdk r0t|jj|j}||}t|Srj)r`rbrArnamesrTrr9)r)r8idxrr*r+r9sz*PandasMultiIndexingAdapter._convert_scalarcs&t|}t|t|r"|j|_|Srj)rrr`r~rA)r)ryrrr*r+r s z&PandasMultiIndexingAdapter.__getitem__r:rcsH|jdkrtSd|jd|jd|jd}t|j|SdS)Nrz, level=r;r)rArrrrr~r-)r)propsrr*r+rs   z#PandasMultiIndexingAdapter.__repr__cCsbtdtdd}|j|krT|d}ttd|t| dg}|t|f}n|}t|S)NdZdisplay_values_thresholdrr)rrrnrkZ concatenaterlrr)r) thresholdposrmZsubsetr*r*r+_get_array_subsets  z,PandasMultiIndexingAdapter._get_array_subsetr) max_widthr5cCs,ddlm}|jdkrdS|||SdS)Nr)format_array_flatZ MultiIndex)xarray.core.formattingrKrArI)r)rJrKr*r*r+ _repr_inline_)s  z(PandasMultiIndexingAdapter._repr_inline_cCs(ddlm}||}dt|dS)Nr)short_numpy_reprz
z
)rLrNrIr )r)rNZ array_reprr*r*r+ _repr_html_1s  z&PandasMultiIndexingAdapter._repr_html_Tr r<cCs,|r|jjddn|j}t|||j|jSr>)rrr~r.rAr?r*r*r+r7szPandasMultiIndexingAdapter.copy)NN)N)T)r-r.r/r0rrrr9rrrIrMrOrrr*r*rr+r@s     r@)NN)N)N)h __future__renumrr collectionsrr contextlibrZ dataclassesrrdatetimerhtmlr typingr r r r rrZnumpyrkZpandasrZpackaging.versionrZ xarray.corerZxarray.core.nputilsrZxarray.core.optionsrZxarray.core.pycompatrrrrZxarray.core.typesrZxarray.core.utilsrrrrZ numpy.typingrr0rZxarray.core.variablerr rGrUrZrirorqrvrzr{rrrrrrrrrZLazilyOuterIndexedArrayrrrrrrrrrEnumrrrrrrrrrrrrrr!rrrrrr@r*r*r*r+s             -&&-),M2 # # R   - 6 +L`