U Cv ft @slddlmZddlZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZddlZddlZddlmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*e rdd l+m,Z,dd l-m.Z.dd l/m0Z0m1Z1m2Z2m3Z3ededZ4dej5dfdddddddddZ6eeeeedffdfZ7ee7eefZ8e e8efZ9e e8e ee(ffZ:Gddde e4Z;ddde<ej5ddddd d!d"d#Z=ddde<dej5fd$dd%d&d'Z>dddej5de<fddd(d)dddd*dd+ d,d-Z?dddej5fdd.d(d)dddd/d0d1Z@d2d3ZAd4d4d5d6d7ZBdd8d4d9d:d;d<ZCdS)=) annotationsN) defaultdict)suppress) TYPE_CHECKINGAnyCallableDictGenericHashableIterableMappingTupleTypeTypeVarcast)dtypes)DataWithCoords)IndexIndexes PandasIndexPandasMultiIndexindexes_all_equalsafe_cast_to_index) is_dict_like is_full_slice)Variableas_compatible_datacalculate_dimensions DataArrayDataset) JoinOptions T_DataArray T_DatasetT_DataWithCoords DataAlignable)boundTFzMapping[Any, Variable]Mapping[Any, Any]boolrzdict[Hashable, Variable]) variablesdim_pos_indexerscopy fill_valuesparsereturnc s"i}t|}ttD]D\}}|dkr@|q t|t||dr |q |D]\} } t |t r|| t j } n|} |r| j | d} tfdd| jD}tfdd| jD} | r| j|| d} n*tdd|Dr | j|d} n| |} | || <qn|S)zConform a dictionary of variables onto a new set of variables reindexed with dimension positional indexers and possibly filled with missing values. Not public API. r)r-c3s.|]&}|krtdn|tdVqdSN)sliceget.0d)r+unchanged_dims9/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/alignment.py Psz$reindex_variables..c3s|]}|kVqdSr0r7r3) masked_dimsr7r8r9Tscss|]}t|VqdSr0)rr4kr7r7r8r9Xsdeep)rsetitemsanyaddnpZ array_equalZaranger2 isinstancedictrNAZ _as_sparsetupledimsZ_getitem_with_maskallr,)r*r+r,r-r. new_variables dim_sizesdimZindxrnamevarZ fill_value_Z needs_maskingZnew_varr7)r+r:r6r8reindex_variables.s4       rO.c @seZdZUdZded<ded<ded<ded<d ed <d ed <d ed <ded<d ed<ded<ded<ded<ded<ded<ded<ded<ded<ded <d!ed"<d#d$eed$d$d%ejd&f d'dd(d)d*d+d,d dd d- d.d/Zd0d1d2d3d4Z d5d6d7d8Z d5d6d9d:Z d5d6d;d<Z d d6d=d>Z d?d6d@dAZd5d6dBdCZd5d6dDdEZd5d6dFdGZddHdIdJdKZdLddMdNdOdPZdLddLdNdQdRZd5d6dSdTZd5d6dUdVZd$S)WAlignerzImplements all the complex logic for the re-indexing and alignment of Xarray objects. For internal use only, not public API. Usage: aligner = Aligner(*objects, **kwargs) aligner.align() aligned_objects = aligner.results tuple[DataAlignable, ...]objectsresultsz)tuple[dict[MatchingIndexKey, Index], ...]objects_matching_indexesstrjoinzfrozenset[Hashable] exclude_dims exclude_varsr)r,rr-r.zdict[MatchingIndexKey, Index]indexesz0dict[MatchingIndexKey, dict[Hashable, Variable]] index_varsz#dict[MatchingIndexKey, list[Index]] all_indexesz6dict[MatchingIndexKey, list[dict[Hashable, Variable]]]all_index_varsaligned_indexesaligned_index_varszdict[MatchingIndexKey, bool]reindexzdict[str, Any]reindex_kwargszdict[Hashable, set]unindexed_dim_sizeszIndexes[Index] new_indexesinnerNTFzIterable[DataAlignable]zMapping[Any, Any] | Noner Iterable[Hashable] str | None*int | float | Iterable[int | float] | None) rRrVrYrWrXmethod tolerancer,r-r.c Cst||_d|_|dkr&td|||_||_| |_| |_|dkrV|dkrVi|_n ||d|_t |t rr|g}t ||_ t ||_ |dkri}||\|_|_i|_i|_i|_i|_i|_i|_t|_dS)Nr7)rcouteroverrideexactleftrightzinvalid value for join: )rgrh)rGrRrT ValueErrorrVr,r-r.r`rDrU frozensetrWrX_normalize_indexesrYrZr[r\rar]r^r_rS) selfrRrVrYrWrXrgrhr,r-r.r7r7r8__init__s2     zAligner.__init__r(z-tuple[NormalizedIndexes, NormalizedIndexVars])rYr/cCst|trt|j}ni}i}|D]\}}t|tst|d|f|fkrdtd|jd|dt |}t |}||_ t|t j rt||}nt|||jd}|||||<q&i}i} t||D]\}} g} t} | D]&\} }|j}| | |f| |q| |j@}|| kr*qnF|rpddd|D}dd d| |D}td |d |t| t|f}|||<| | |<q|| fS) zNormalize the indexes/indexers used for re-indexing or alignment. Return dictionaries of xarray Index objects and coordinate variables such that we can group matching indexes based on the dictionary keys. rHzIndexer has dimensions z3 that are different from that to be indexed along '')Z coord_dtype, css|]}t|VqdSr0rUr3r7r7r8r9sz-Aligner._normalize_indexes..css|]}t|VqdSr0rur3r7r7r8r9szcannot exclude dimension(s) zY from alignment because these are used by an index together with non-excluded dimensions )rDrrEr*r@rgetattrrnrHrrrMpdZ MultiIndexrrZdtypeupdatecreate_variablesZgroup_by_indexr?appendrWrVrGtype)rqrYZ xr_variablesZ xr_indexesr<idxdataZpd_idxZnormalized_indexesZnormalized_index_varsrZZcoord_names_and_dimsZall_dimsrMrNrHrWZ excl_dims_strZ incl_dims_strkeyr7r7r8rpsP          zAligner._normalize_indexesNone)r/cCstt}tt}tdd}g}|jD]}||j\}}|||D]\}} ||| qL|D]>\}} ||| t| D]\} } ||| | qqlq&t ||_ ||_ ||_ |j dkr |D]2} | D]$\} }t|dkrtd| dqqdS)NcSsttSr0)rr?r7r7r7r8z/Aligner.find_matching_indexes..rjzPcannot align objects with join='override' with matching indexes along dimension z that don't have the same size)rlistrRrpxindexesrzr@rrBrGrTr[r\rVvalueslenrn)rqr[r\Zall_indexes_dim_sizesrTobjZ obj_indexesZobj_index_varsr~r|rZrLsizerKsizesr7r7r8find_matching_indexess.        zAligner.find_matching_indexescCsTtt}|jD]:}|jD].}||jkr||jjkr|||j|qq||_dSr0) rr?rRrHrWrrBrra)rqrarrLr7r7r8find_matching_unindexed_dimss   z$Aligner.find_matching_unindexed_dimscCst|jt|jB}tt}tt}|D]P\}}t}|D]"\}}||d7<||q:|D]} || d7<qbq(|df|dffD]L\} } dd| D} | rddd| D} td | d | d qd S) aRCheck for uniqueness of both coordinate and dimension names across all sets of matching indexes. We need to make sure that all indexes used for re-indexing or alignment are fully compatible and do not conflict each other. Note: perhaps we could choose less restrictive constraints and instead check for conflicts among the dimension (position) indexers returned by `Index.reindex_like()` for each matching pair of object index / aligned index? (ref: https://github.com/pydata/xarray/issues/1603#issuecomment-442965602) rZ coordinatesZ dimensionscSsi|]\}}|dkr||qS)rr7r4r<vr7r7r8 Asz4Aligner.assert_no_index_conflict..rtcss"|]\}}|d|dVqdS)z (z conflicting indexes)Nr7rr7r7r8r9Csz3Aligner.assert_no_index_conflict..zRcannot re-index or align objects with conflicting indexes found for the following : z Conflicting indexes may occur when - they relate to different sets of coordinate and/or dimension names - they don't have the same type - they may be used to reindex data along common dimensionsN) r?r[rYrintrxr@rVrn)rqZ matching_keysZ coord_countZ dim_countZcoord_names_dims_Zdims_setrMrHrLcountmsgdupZ items_msgr7r7r8assert_no_index_conflict&s&    z Aligner.assert_no_index_conflictc Cst|s dSi}|D]:}||jkr|j|}t|dkr>dStt|||<q|ri}|D]&}|d}|D]} || jqpq\|D]\}} | |d| krdSqdS)aWhether or not we need to reindex variables for a set of matching indexes. We don't reindex when all matching indexes are equal for two reasons: - It's faster for the usual case (already aligned objects). - It ensures it's possible to do operations that don't require alignment on indexes with duplicate values (which cannot be reindexed with pandas). This is useful, e.g., for overwriting such duplicate indexes. TrF) rrarnextiterrrxrr@r2) rqrH cmp_indexesZunindexed_dims_sizesrLrZindexed_dims_sizescmprZrNrr7r7r8 _need_reindexOs&     zAligner._need_reindexrcCsn|jdkr&ttjtj|j|jdS|jdkr:tdS|jdkrNtdS|jdkrbtdSdd SdS) N)rirc)howrlrrmrrjcSsdSr0r7)rr7r7r8rrz+Aligner._get_index_joiner..)rV functoolspartialreduceoperator itemgetter)rq index_clsr7r7r8_get_index_joinervs       zAligner._get_index_joinercCs.i}i}i}i}i}|jD]\}}|j|}dd|dD} |d} |jdkrp|d} |d} d} n||jkr|j|} |j|} tt| g|| g|}| | |} nt |dkr| | tt||} nd} | rX|jdkrt dd d d |dD| | }||} |jd kr8|d} n|jd krN|d} n| } n|d} |d} | ||<| ||<| ||<| D]\}}| ||<|||<qq|jD]Z\}}||kr|j|}d||<|||<|||<|D]\}}|||<|||<qq||_||_||_t|||_dS)zICompute all aligned indexes and their corresponding coordinate variables.cSsh|]}|jD]}|qqSr7rH)r4Zcoordr5r7r7r8 sz(Aligner.align_indexes..rrrjFrkztcannot align objects with join='exact' where index/labels/sizes are not equal along these coordinates (dimensions): rtcss |]\}}|d|VqdS) Nr7)r4rMrHr7r7r8r9sz(Aligner.align_indexes..rlrmrN)r[r@r\rrVrYrZrziprrrnrryr]r^r_rrb)rqr]r^r_rbZnew_index_varsr~matching_indexesZmatching_index_varsrHrZ joined_indexZjoined_index_varsZ need_reindexrjoinerrMrNr|rZr7r7r8 align_indexess                zAligner.align_indexescCsn|jD]^\}}|jj|}|dk r@||d|d}nd}t|dkr td|d||q dS)Nz9 (note: an index is found along that dimension with size=)rz(cannot reindex or align along dimension z) because of conflicting dimension sizes: )rar@rbrHr2rBrrn)rqrLrZ index_sizeZ add_err_msgr7r7r8 assert_unindexed_dim_sizes_equals   z(Aligner.assert_unindexed_dim_sizes_equalc Cst|j}t|ddD]\}}i}i}|j|d}|jD]L\}}||} | dk rB|j|D]"\} } ||| <| j|jd|| <qjqB| ||||d<qt ||_ dS)Nrr=) rrR enumeraterTr]r@r2r^r,Z_overwrite_indexesrGrS) rqrRirrbrJrr~ aligned_idxobj_idxrMrNr7r7r8override_indexess  zAligner.override_indexeszdict[Hashable, Any])rr/cCsRi}|jD]>\}}||}|dk r|j|r|j|f|j}||q|Sr0)r]r@r2r_ reindex_liker`rx)rqrr+r~rrindexersr7r7r8_get_dim_pos_indexerss   zAligner._get_dim_pos_indexersr&z6tuple[dict[Hashable, Index], dict[Hashable, Variable]])rrr/c Csi}i}|jD]|\}}|j|}||}|dkrZdd|D} | t|jkrZ|}|dk r|D]"\} } ||| <| j|jd|| <qjq||fS)NcSsh|]}|jD]}|qqSr7r)r4rNr5r7r7r8rsz0Aligner._get_indexes_and_vars..r=)r]r@r^r2rr?rHr,) rqrrrbrJr~rrZrZindex_vars_dimsrMrNr7r7r8_get_indexes_and_vars s  zAligner._get_indexes_and_varsc CsB|||\}}||}||||||j|j|j}|j|_|Sr0)rrZ_reindex_callbackr-rWrXencoding)rqrrrbrJr+Znew_objr7r7r8 _reindex_one"s  zAligner._reindex_onecs&tfddtjjD_dS)Nc3s|]\}}||VqdSr0)r)r4rrrqr7r8r97sz&Aligner.reindex_all..)rGrrRrTrSrr7rr8 reindex_all6s  zAligner.reindex_allcCsz|js2t|jdkr2|j\}|j|jdf|_dS||||| |j dkrn| n| dS)Nrr=rj) rYrrRr,rSrrrrrrVrr)rqrr7r7r8align>s  z Aligner.align)__name__ __module__ __qualname____doc____annotations__rorrFrrrprrrrrrrrrrrrrr7r7r7r8rPksX  "0>" )'QrPrcrVr,rYexcluder-r"rQ)rRrVr,r/cGs"t||||||d}||jS)a` Given any number of Dataset and/or DataArray objects, returns new objects with aligned indexes and dimension sizes. Array from the aligned objects are suitable as input to mathematical operators, because along each dimension they have the same index and size. Missing values (if ``join != 'inner'``) are filled with ``fill_value``. The default fill value is NaN. Parameters ---------- *objects : Dataset or DataArray Objects to align. join : {"outer", "inner", "left", "right", "exact", "override"}, optional Method for joining the indexes of the passed objects along each dimension: - "outer": use the union of object indexes - "inner": use the intersection of object indexes - "left": use indexes from the first object with each dimension - "right": use indexes from the last object with each dimension - "exact": instead of aligning, raise `ValueError` when indexes to be aligned are not equal - "override": if indexes are of same size, rewrite indexes to be those of the first object with that dimension. Indexes for the same dimension must have the same size in all objects. copy : bool, default: True If ``copy=True``, data in the return values is always copied. If ``copy=False`` and reindexing is unnecessary, or can be performed with only slice operations, then the output may share memory with the input. In either case, new xarray objects are always returned. indexes : dict-like, optional Any indexes explicitly provided with the `indexes` argument should be used in preference to the aligned indexes. exclude : sequence of str, optional Dimensions that must be excluded from alignment fill_value : scalar or dict-like, optional Value to use for newly missing values. If a dict-like, maps variable names to fill values. Use a data array's name to refer to its values. Returns ------- aligned : tuple of DataArray or Dataset Tuple of objects with the same type as `*objects` with aligned coordinates. Raises ------ ValueError If any dimensions without labels on the arguments have different sizes, or a different size than the size of the aligned dimension labels. Examples -------- >>> x = xr.DataArray( ... [[25, 35], [10, 24]], ... dims=("lat", "lon"), ... coords={"lat": [35.0, 40.0], "lon": [100.0, 120.0]}, ... ) >>> y = xr.DataArray( ... [[20, 5], [7, 13]], ... dims=("lat", "lon"), ... coords={"lat": [35.0, 42.0], "lon": [100.0, 120.0]}, ... ) >>> x array([[25, 35], [10, 24]]) Coordinates: * lat (lat) float64 35.0 40.0 * lon (lon) float64 100.0 120.0 >>> y array([[20, 5], [ 7, 13]]) Coordinates: * lat (lat) float64 35.0 42.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y) >>> a array([[25, 35]]) Coordinates: * lat (lat) float64 35.0 * lon (lon) float64 100.0 120.0 >>> b array([[20, 5]]) Coordinates: * lat (lat) float64 35.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y, join="outer") >>> a array([[25., 35.], [10., 24.], [nan, nan]]) Coordinates: * lat (lat) float64 35.0 40.0 42.0 * lon (lon) float64 100.0 120.0 >>> b array([[20., 5.], [nan, nan], [ 7., 13.]]) Coordinates: * lat (lat) float64 35.0 40.0 42.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y, join="outer", fill_value=-999) >>> a array([[ 25, 35], [ 10, 24], [-999, -999]]) Coordinates: * lat (lat) float64 35.0 40.0 42.0 * lon (lon) float64 100.0 120.0 >>> b array([[ 20, 5], [-999, -999], [ 7, 13]]) Coordinates: * lat (lat) float64 35.0 40.0 42.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y, join="left") >>> a array([[25, 35], [10, 24]]) Coordinates: * lat (lat) float64 35.0 40.0 * lon (lon) float64 100.0 120.0 >>> b array([[20., 5.], [nan, nan]]) Coordinates: * lat (lat) float64 35.0 40.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y, join="right") >>> a array([[25., 35.], [nan, nan]]) Coordinates: * lat (lat) float64 35.0 42.0 * lon (lon) float64 100.0 120.0 >>> b array([[20, 5], [ 7, 13]]) Coordinates: * lat (lat) float64 35.0 42.0 * lon (lon) float64 100.0 120.0 >>> a, b = xr.align(x, y, join="exact") Traceback (most recent call last): ... ValueError: cannot align objects with join='exact' ... >>> a, b = xr.align(x, y, join="override") >>> a array([[25, 35], [10, 24]]) Coordinates: * lat (lat) float64 35.0 40.0 * lon (lon) float64 100.0 120.0 >>> b array([[20, 5], [ 7, 13]]) Coordinates: * lat (lat) float64 35.0 40.0 * lon (lon) float64 100.0 120.0 )rVr,rYrWr-rPrrS)rVr,rYrr-rRalignerr7r7r8rQsErz Iterable[Any])rRrVcspddlmddlm|dkr$i}fdd}g}g} g} g} t} t} t|D]\}}||r||| | | || | qVt|ri}|D]H\}}||r||kr||| || || ||<q|||<q| |qV|rt d |qV| |qVt | |||||d}t || |D],\}}}|| kr\|| |<n || ||<q>| S) zgAlign objects for merging, recursing into dictionary values. This function is not public API. rrr Ncst|fSr0)rD)rrr!r7r8 is_alignable4sz deep_align..is_alignablezXobject to align is neither an xarray.Dataset, an xarray.DataArray nor a dictionary: {!r}r) xarray.core.dataarrayrxarray.core.datasetr!objectrrzrr@rnformatrr)rRrVr,rYrZraise_on_invalidr-rZ positionskeysouttargetsZno_keyZ not_replacedpositionr*Z current_outr<rZalignedr~Z aligned_objr7rr8 deep_align!s^                rrerfrd) rrrgrhr,r-r.rXr/c Cs,t|f|||||||d}||jdS)zDRe-index either a Dataset or a DataArray. Not public API. )rYrgrhr,r-r.rXrr) rrrgrhr,r-r.rXrr7r7r8r_ns r_zDataset | DataArray)rotherrgrhr,r-r/c Csh|jsR|jD]D}||jkr |j|}|j|}||kr td|d|d|q t||j||||dS)zcRe-index either a Dataset or a DataArray like another Dataset/DataArray. Not public API. z3different size for unlabeled dimension on argument rz vs )rrgrhr,r-)_indexesrHrrnr_r) rrrgrhr,r-rLZ other_sizeZobj_sizer7r7r8rs"     rcCs`i}i}|D]J}|jD]>}||kr||kr|j|||<||jkr||j|qq ||fSr0)rHrrrxrZget_all_coords)argsr common_coordsdims_mapargrLr7r7r8%_get_broadcast_dims_map_common_coordss  rr%)rr/csddlm}ddlm}fdddddfdd }d d d fd d }t||rjtd||St||rtd||StddS)Nrrr c sF}D].}tt|j|j|||<W5QRXq ||Sr0)r,rrnshaperHindexZset_dims)rNZ var_dims_maprL)rrr7r8 _set_dimss  "z$_broadcast_helper.._set_dimsr#)arrayr/cs8|j}t|j}||j|||j|j|jdS)N)rMattrs)variablerEcoordsrx __class__rHrMr)rr}rrrr7r8_broadcast_arrays   z+_broadcast_helper.._broadcast_arrayr$)dsr/cs:fddjD}tj}|||jS)Ncsi|]}|j|qSr7)r*r;)rrr7r8rszA_broadcast_helper.._broadcast_dataset..) data_varsrErrxrr)rrrr)rr8_broadcast_datasets  z-_broadcast_helper.._broadcast_datasetr%z.all input must be Dataset or DataArray objects)rrrr!rDrrn)rrrrrr!rrr7)rrrrr8_broadcast_helpers     r)rztuple[T_DataWithCoords, ...])rr/csLdkrtt|ddd}t|\fdd|D}t|S)a^Explicitly broadcast any number of DataArray or Dataset objects against one another. xarray objects automatically broadcast against each other in arithmetic operations, so this function should not be necessary for normal use. If no change is needed, the input data is returned to the output without being copied. Parameters ---------- *args : DataArray or Dataset Arrays to broadcast against each other. exclude : sequence of str, optional Dimensions that must not be broadcasted Returns ------- broadcast : tuple of DataArray or tuple of Dataset The same data as the input arrays, but with additional dimensions inserted so that all data arrays have the same dimensions and shape. Examples -------- Broadcast two data arrays against one another to fill out their dimensions: >>> a = xr.DataArray([1, 2, 3], dims="x") >>> b = xr.DataArray([5, 6], dims="y") >>> a array([1, 2, 3]) Dimensions without coordinates: x >>> b array([5, 6]) Dimensions without coordinates: y >>> a2, b2 = xr.broadcast(a, b) >>> a2 array([[1, 1], [2, 2], [3, 3]]) Dimensions without coordinates: x, y >>> b2 array([[5, 6], [5, 6], [5, 6]]) Dimensions without coordinates: x, y Fill out the dimensions of all data variables in a dataset: >>> ds = xr.Dataset({"a": a, "b": b}) >>> (ds2,) = xr.broadcast(ds) # use tuple unpacking to extract one dataset >>> ds2 Dimensions: (x: 3, y: 2) Dimensions without coordinates: x, y Data variables: a (x, y) int64 1 1 2 2 3 3 b (x, y) int64 5 6 5 6 5 6 NriF)rVr,rcsg|]}t|qSr7)r)r4rrrrr7r8 5szbroadcast..)r?rrrG)rrresultr7rr8 broadcasts @r)D __future__rrr collectionsr contextlibrtypingrrrrr r r r r rrrZnumpyrCZpandasrwZ xarray.corerZxarray.core.commonrZxarray.core.indexesrrrrrrZxarray.core.utilsrrZxarray.core.variablerrrrrrr!Zxarray.core.typesr"r#r$r%r&rFrOZCoordNamesAndDimsZMatchingIndexKeyZNormalizedIndexesZNormalizedIndexVarsrProrrr_rrrrr7r7r7r8st   8      7 kSP *#*