U Cv f @sTddlmZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZmZddlZddlZddlmZddlmZddlZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$ddl%m&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1dd l2m3Z3m4Z4m5Z5dd l6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAe!jBejCfZDe4eEfZFe rddlGmHZHmIZImJZJmKZKmLZLmMZMdZNGdddeOZPd:ddddZQddZRddZSddZTddZUd;dd ZVd!d"ZWGd#d$d$e(e8e&ZXGd%d&d&eXZYe$ZeYd'Z[d(d)Z\d*d+Z]d$d,d-d.d/Z^d0d1Z_d|jdk}|sH|rtt j ddt|tjrvtd|j }nd}| |S|jdkr|tdkrtt j dd| dS|SdS) NMzdatetime64[ns]nsdatetime)Zcasemztimedelta64[ns]r) dtypekindrDnprNZDatetimeTZDtypeunitrZemit_user_level_warningNON_NANOSECOND_WARNINGrLtzastype)r[rcZnon_ns_datetime64Znon_ns_datetime_tz_dtypeZnanosecond_precision_dtyper8r8r9_as_nanosecond_precisions$      rjcCs4t|}|jjdkr"t|}t||j S)aConvert arrays of datetime.datetime and datetime.timedelta objects into datetime64 and timedelta64, according to the pandas convention. For the time being, convert any non-nanosecond precision DatetimeIndex or TimedeltaIndex objects to nanosecond precision. While pandas is relaxing this in version 2.0.0, in xarray we will need to make sure we are ready to handle non-nanosecond precision datetimes or timedeltas in our code before allowing such values to pass through unchanged. Converting to nanosecond precision through pandas.Series objects ensures that datetimes and timedeltas are within the valid date range for ns precision, as pandas will raise an error if they are not. ZmM) rNSeriesravelrcrdrjreasarrayreshapeshape)valuesZ as_seriesr8r8r9_possibly_convert_objectss  rqcCs"t|tjtjfrt|S|SdS)aiFor the time being, convert any non-nanosecond precision DatetimeIndex or TimedeltaIndex objects to nanosecond precision. While pandas is relaxing this in version 2.0.0, in xarray we will need to make sure we are ready to handle non-nanosecond precision datetimes or timedeltas in our code before allowing such values to pass through unchanged.N)rDrNZ DatetimeIndexZTimedeltaIndexrjr]r8r8r9-_possibly_convert_datetime_or_timedelta_indexsrrFcCsv|rt|dddkrt|Sddlm}t|t|fr<|jSt|trVt|}t|St|t rjt |}t|t j rt|jd}t|trtt|d|d}t|t jt jt jfr|j}t|tjjrtj|}|r t|j\}}tj||d}|||<n t|}t|tjs@t |dsd?Z!dd@d@dAdBdCdDZ"edEd dFdGZ#e#j dHdIdJdKdGZ#dHdEdLdMdNZ$dOdPZ%dQdRZ&dSdTZ'dUdVZ(dWdXZ)dYdZZ*d[d\Z+dddd]d^Z,dddd_d`Z-e.j/fdadbZ0dcddZ1eded dfdgZ2e2j dhdIdJdidgZ2eded djdkZ3e3j dldkZ3ddd@dmddndodpZ4ddd@dmdqddrdsdtZ5e6e6e6e6fddddudvZ7ddddwdxZ8dddqddydzd{Z9dZ:ed|d d}d~Z;edd ddZZ?idddfddd@d@dddddZ@dd ddZAdddddZBe6e.j/fddZCddZDdddddddddZEdddZFe.j/fddZGde.j/fddZHdddddZIddddddddddddZJddZKdddZLddddddddZMedd ddZNdddZOdddddZPdddZQddddddZRe.j/dfddd@ddÜddńZSdddDŽZTddɄZUe.j/fdd˄ZVddd̈́ZWdddddd@ddќddӄZXeYdddׄZZe[j\fddلZ]e[j\fddۄZ^e[j\fdd݄Z_e[j`fdd߄Zad ddddddddddZbd!ddZcde.j/fddZdd"ddZeddZfd#ddddZgd$ddddZheddZieddZjd%ddZkddZld&ddZmddZnddeofddZpddϐdddddd d Zqd'dϐddddd d d Zrd(dϐddddd ddZsdS()rFaA netcdf-like variable consisting of dimensions, data and attributes which describe a single Array. A single Variable object is not fully described outside the context of its parent Dataset (if you want such a fully described object, use a DataArray instead). The main functional difference between Variables and numpy arrays is that numerical operations on Variables implement array broadcasting by dimension name. For example, adding an Variable with dimensions `('time',)` to another Variable with dimensions `('space',)` results in a new Variable with dimensions `('time', 'space')`. Furthermore, numpy reduce operations like ``mean`` or ``sum`` are overwritten to take a "dimension" argument instead of an "axis". Variables are light-weight objects used as the building block for datasets. They are more primitive objects, so operations with them provide marginally higher performance than using DataArrays. However, manipulating data in the form of a Dataset or DataArray should almost always be preferred, because they can use more complete metadata in context of coordinate labels. )_dims_data_attrs _encodingNFcCsFt||d|_|||_d|_d|_|dk r4||_|dk rB||_dS)a Parameters ---------- dims : str or sequence of str Name(s) of the the data dimension(s). Must be either a string (only for 1D data) or a sequence of strings with length equal to the number of dimensions. data : array_like Data array which supports numpy-like data access. attrs : dict_like or None, optional Attributes to assign to the new variable. If None (default), an empty attribute dictionary is initialized. encoding : dict_like or None, optional Dictionary specifying how to encode this array's data into a serialized format like netCDF4. Currently used keys (for netCDF) include '_FillValue', 'scale_factor', 'add_offset' and 'dtype'. Well-behaved code to serialize a Variable should ignore unrecognized encoding items. rAN)rUr_parse_dimensionsrrrattrsencodingselfrWr[rrrBr8r8r9__init__Ys zVariable.__init__cCs|jjS)u Data-type of the array’s elements. See Also -------- ndarray.dtype numpy.dtype )rrcrr8r8r9rcvs zVariable.dtypecCs|jjS)zk Tuple of array dimensions. See Also -------- numpy.ndarray.shape )rrorr8r8r9ros zVariable.shapeintr:cCs&t|jdr|jjS|j|jjSdS)z Total bytes consumed by the elements of the data array. If the underlying data array does not include ``nbytes``, estimates the bytes consumed based on the ``size`` and ``dtype``. nbytesN)r}rrsizercitemsizerr8r8r9rs zVariable.nbytescCs4t|jtjtjtfp2t|jtjo2t|jjtj SN) rDrrer|numberrrMemoryCachedArrayarrayZNumpyIndexingAdapterrr8r8r9 _in_memorys zVariable._in_memoryrcCst|jr|jS|jSdS)z The Variable's data as an array. The underlying array type (e.g. dask, sparse, pint) is preserved. See Also -------- Variable.to_numpy Variable.as_numpy Variable.values N)r+rrprr8r8r9r[s z Variable.datacCs6t|}|j|jkr,td|jd|j||_dS)NzMreplacement data must match the Variable's shape. replacement data has shape z; Variable has shape )rUrorJrrr[r8r8r9r[s  T)ordercastingsubokrG keep_attrsr2)rr;c CsDddlm}t||||d}dd|D}|tj||||ddS)u Copy of the Variable object, with data cast to a specified type. Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. order : {'C', 'F', 'A', 'K'}, optional Controls the memory layout order of the result. ‘C’ means C order, ‘F’ means Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran contiguous, ‘C’ order otherwise, and ‘K’ means as close to the order the array elements appear in memory as possible. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur. * 'no' means the data types should not be cast at all. * 'equiv' means only byte-order changes are allowed. * 'safe' means only casts which can preserve values are allowed. * 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. * 'unsafe' means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to False and the `dtype` requirement is satisfied, the input array is returned instead of a copy. keep_attrs : bool, optional By default, astype keeps attributes. Set to False to remove attributes in the returned object. Returns ------- out : same as object New object with data cast to the specified type. Notes ----- The ``order``, ``casting``, ``subok`` and ``copy`` arguments are only passed through to the ``astype`` method of the underlying array when a value different than ``None`` is supplied. Make sure to only supply these arguments if the underlying array class supports them. See Also -------- numpy.ndarray.astype dask.array.Array.astype sparse.COO.astype r apply_ufunc)rrrrGcSsi|]\}}|dk r||qSrr8.0kvr8r8r9 sz#Variable.astype..allowed)kwargsrdask)xarray.core.computationrrSitemsrri) rrcrrrrGrrrr8r8r9ris= zVariable.astypecKs<t|jr t|jjf||_nt|js8t|j|_|S)a Manually trigger loading of this variable's data from disk or a remote source into memory and return this variable. Normally, it should not be necessary to call this method in user code, because all xarray functions should either work on deferred data or load data automatically. Parameters ---------- **kwargs : dict Additional keyword arguments passed on to ``dask.array.compute``. See Also -------- dask.array.compute )r!rrUcomputer+rerm)rrr8r8r9load s   z Variable.loadcKs|jdd}|jf|S)a5Manually trigger loading of this variable's data from disk or a remote source into memory and return a new variable. The original is left unaltered. Normally, it should not be necessary to call this method in user code, because all xarray functions should either work on deferred data or load data automatically. Parameters ---------- **kwargs : dict Additional keyword arguments passed on to ``dask.array.compute``. See Also -------- dask.array.compute Fr>)rGr)rrnewr8r8r9r s zVariable.computecCs&ddlm}|t||j|j|jfSNr)normalize_token) dask.baserrTrr[rrrr8r8r9__dask_tokenize__5s zVariable.__dask_tokenize__cCst|jr|jSdSdSr)r!r__dask_graph__rr8r8r9r<s  zVariable.__dask_graph__cCs |jSr)r __dask_keys__rr8r8r9rBszVariable.__dask_keys__cCs |jSr)r__dask_layers__rr8r8r9rEszVariable.__dask_layers__cCs|jjSr)r__dask_optimize__rr8r8r9rHszVariable.__dask_optimize__cCs|jjSr)r__dask_scheduler__rr8r8r9rLszVariable.__dask_scheduler__cCs|j\}}|j|f|fSr)r__dask_postcompute___dask_finalizer array_funcZ array_argsr8r8r9rPszVariable.__dask_postcompute__cCs|j\}}|j|f|fSr)r__dask_postpersist__rrr8r8r9rTszVariable.__dask_postpersist__cOs&||f||}t|j||j|jdS)N)rr)rFrrr)rresultsrargsrr[r8r8r9rXszVariable._dask_finalizecCs t|jS)z&The variable's data as a numpy.ndarray)rrrr8r8r9rp\szVariable.valuescCs ||_dSrr]rrpr8r8r9rpascCst|j|j|j|jddS)z.Return this variable as a base xarray.VariableTrrB)rFrrrrrr8r8r9to_base_variableeszVariable.to_base_variable to_variablerPcCst|j|j|j|jddS)/Return this variable as an xarray.IndexVariableTr)rPrrrrrr8r8r9rXmszVariable.to_index_variableto_coordpd.IndexcCs |Sr)rX _to_indexrr8r8r9ruszVariable._to_indexcCs |S)'Convert this variable to a pandas.Index)rXto_indexrr8r8r9rxszVariable.to_indexboolrS)r[rr;cCsX|jt|jd}|r*t|j|d<n|t|j|j d|rTt |j |d<|S)z&Dictionary representation of variable.)rWrr[)rcror) rWr&rr)rptolistupdatestrrcrorSr)rr[ritemr8r8r9to_dict|szVariable.to_dictztuple[Hashable, ...]cCs|jS)z@Tuple of dimension names with which this variable is associated.)rrr8r8r9rWsz Variable.dimszstr | Iterable[Hashable]None)rsr;cCs|||_dSr)rrrrsr8r8r9rWs)rWr;cCs@t|tr|f}t|}t||jkrsz.Variable._item_key_to_tuple..)r is_dict_likerHrW)rrr8rr9_item_key_to_tuples zVariable._item_key_to_tuplecCs||}t||j}tdd|D}tdd|D}tdd|DrX||S||tdd|Dr~||Sg}t ||j D]T\}}t |t rt |j dkr||S||j dqt |ts||qt t|t |kr||S||S)aPrepare an indexing key for an indexing operation. Parameters ---------- key : int, slice, array-like, dict or tuple of integer, slice and array-like Any valid input for indexing. Returns ------- dims : tuple Dimension of the resultant variable. indexers : IndexingTuple subclass Tuple of integer, array-like, or slices to use when indexing self._data. The type of this argument indicates the type of indexing to perform, either basic, outer or vectorized. new_order : Optional[Sequence[int]] Optional reordering to do on the result of indexing. If not None, the first len(new_order) indexing should be moved to these positions. css0|](}t|tr$|jdkr$|jn|VqdSrN)rDrFrVr[rrrr8r8r9rsz.Variable._broadcast_indexes..css0|](}t|tjr$|jdkr$|n|VqdSr)rDrer|rVrrr8r8r9rscss|]}t|tVqdSr)rDBASIC_INDEXING_TYPESrr8r8r9rscss|]}t|t VqdSr)rDrFrr8r8r9rsr@r)rrZexpanded_indexerrVrHall_broadcast_indexes_basic_validate_indexers_broadcast_indexes_outerziprWrDrFr_broadcast_indexes_vectorizedappendr rR)rrrWrdr8r8r9_broadcast_indexess0        zVariable._broadcast_indexescCs(tddt||jD}|t|dfS)Ncss |]\}}t|ts|VqdSr)rDr rrrr8r8r9rs z4Variable._broadcast_indexes_basic..)rHrrWr)rrrWr8r8r9rs z!Variable._broadcast_indexes_basiccCst|j|D]\}}t|ts t|tsJt|}|jdkrJtd ||j j dkr |j | |t|krtd t|t|j |jdkrtd |jt|d|f|fkr td t|j|q dS) zMake sanity checksr@zAUnlabeled multi-dimensional array cannot be used for indexing: {}bz?Boolean array size {:d} is used to index array with shape {:s}.z2{}-dimensional boolean indexing is not supported. rWzBoolean indexer should be unlabeled or on the same dimension to the indexed array. Indexer is on {:s} but the target dimension is {:s}.N)rrWrDrrFrermrV IndexErrorrLrcrdro get_axis_numrrru)rrrrr8r8r9rs>      zVariable._validate_indexerscCstddt||jD}g}|D]`}t|tr6|j}t|tsxt|}|j dkr`| t }n|j j dkrxt|\}||q"|tt|dfS)Ncss4|],\}}t|tst|tr(|jdn|VqdSr)rDr rFrWrr8r8r9rs z4Variable._broadcast_indexes_outer..rr)rHrrWrDrFr[rrermrrirrcrdnonzerorr)rrrWZnew_keyrr8r8r9rs         z!Variable._broadcast_indexes_outercCs&t|j}tddt||jDS)z.)rerr[rHrrW)rZnonzerosr8r8r9_nonzeros zVariable._nonzerocsg}t}t|j|D]d\}}t|tr4||qt|trB|n t||d}|jj dkrd| \}| || |jqt }|D]}| |jqg}tt|j|D]b\} \}}t|tr||krtj||j|} || t|t|f| q| | |fqz t|}Wn$tk r@td|YnXdd|D} t|} t |D]0\} }| | || |j| } | qbrfddtt| D}nd}| tt| |fS)N)rQrz!Dimensions of indexers mismatch: cSsg|] }|jqSr8r])rrEr8r8r9 Hsz:Variable._broadcast_indexes_vectorized..csg|]}|kr|qSr8r8riZslice_positionsr8r9rQs)r$rrWrDraddrFr\rcrdrrrrR enumeraterearangeindicessizesinsertr_broadcast_compat_variablesrJrrHindexranger)rr variablesZ out_dims_setrrsrEZ variable_dimsslicesrrpZout_keyZout_dimsZ new_position new_orderr8rr9rsL           z&Variable._broadcast_indexes_vectorizedcCsD||\}}}t|j|}|r8t|tt||}|||S)a_Return a new Variable object whose contents are consistent with getting the provided key from the underlying data. NB. __getitem__ and __setitem__ implement xarray-style indexing, where if keys are unlabeled arrays, we index the array orthogonally with them. If keys are labeled array (such as Variables), they are broadcasted with our usual scheme and then the array is indexed with the broadcasted key, like numpy's fancy indexing. If you really want to do indexing like `x[x > 0]`, manipulate the numpy array `x.values` directly. )rrrremoveaxisrr_finalize_indexing_result)rrrWindexerrr[r8r8r9 __getitem__Ws zVariable.__getitem__cCs|j||dS)zDUsed by IndexVariable to return IndexVariable objects when possible.rWr[)_replacerrWr[r8r8r9rjsz"Variable._finalize_indexing_resultc Cs|tjkrt|j}||\}}}|jrzt|jrBt |}n|}t |j|}t ||j |}t t|||}n"t ||j }t|t|dd}|rt |tt||}|||S)z3Index this Variable with -1 remapped to fill_value.ror8)rNAget_fill_valuercrrr!rrZposify_mask_indexerrZ create_maskrorwherereZ logical_not broadcast_torurrrr) rrrrWrrZactual_indexerr[r~r8r8r9_getitem_with_maskns    zVariable._getitem_with_maskcCs||\}}}t|tsxt|}|jt|krLtd|jdt|d|jdkrbtd|}nt||j d|}||j }|rt |}|t||jt j ftf}t ||tt|}t|j}|||<dS)z__setitem__ is overloaded to access the underlying numpy values with orthogonal indexing. See __getitem__ for more details. z%shape mismatch: value array of shape z0 could not be broadcast to indexing result with z dimensionsrr8N)rrDrFrUrVrrJroset_dimsr[rrmrenewaxisEllipsisrrrr)rrrsrWZ index_tuplerZ indexabler8r8r9 __setitem__s"       zVariable.__setitem__zdict[Any, Any]cCs|jdkri|_|jS)z0Dictionary of local attributes on this variable.N)rrr8r8r9rs zVariable.attrszMapping[Any, Any]cCst||_dSr)rSrrr8r8r9rscCs|jdkri|_|jS)z)Dictionary of encodings on this variable.N)rrr8r8r9rs zVariable.encodingcCs0zt||_Wntk r*tdYnXdS)Nz)encoding must be castable to a dictionary)rSrrJrr8r8r9rsArrayLike | None)rr?r[r;cCs|j||dS)aReturns a copy of this object. If `deep=True`, the data array is loaded into memory and copied onto the new object. Dimensions, attributes and encodings are always copied. Use `data` to create a new object with the same structure as original but entirely new data. Parameters ---------- deep : bool, default: True Whether the data array is loaded into memory and copied onto the new object. Default is True. data : array_like, optional Data to use in the new object. Must have same shape as original. When `data` is used, `deep` is ignored. Returns ------- object : Variable New object with dimensions, attributes, encodings, and optionally data copied from original. Examples -------- Shallow copy versus deep copy >>> var = xr.Variable(data=[1, 2, 3], dims="x") >>> var.copy() array([1, 2, 3]) >>> var_0 = var.copy(deep=False) >>> var_0[0] = 7 >>> var_0 array([7, 2, 3]) >>> var array([7, 2, 3]) Changing the data using the ``data`` argument maintains the structure of the original object, but with the new data. Original object is unaffected. >>> var.copy(data=[0.1, 0.2, 0.3]) array([0.1, 0.2, 0.3]) >>> var array([7, 2, 3]) See Also -------- pandas.DataFrame.copy r?r[_copy)rr?r[r8r8r9rGs:z Variable.copyzdict[int, Any] | None)rr?r[memor;cCs|dkr8|j}t|tjr&t|j}|r`t||}n(t|}|j|jkr`t d |j|j|rrt|j |n t|j }|rt|j |n t|j }|j |||dS)N+Data shape {} must match shape of object {}r[rr)rrDrrrrGdeepcopyrUrorJrLrrr)rr?r[rndatarrr8r8r9r  s$   zVariable._copycCsf|tkrt|j}|tkr(t|j}|tkrr rr8r8r9__copy__;szVariable.__copy__)rrr;cCs|jd|dS)NT)r?rr )rrr8r8r9 __deepcopy__>szVariable.__deepcopy__z"tuple[tuple[int, ...], ...] | NonecCst|jddS)a  Tuple of block lengths for this dataarray's data, in order of dimensions, or None if the underlying data is not a dask array. See Also -------- Variable.chunk Variable.chunksizes xarray.unify_chunks chunksN)rurrr8r8r9rGs zVariable.chunkszMapping[Any, tuple[int, ...]]cCs2t|jdr*tddt|j|jjDSiSdS)a Mapping from dimension names to block lengths for this variable's data, or None if the underlying data is not a dask array. Cannot be modified directly, but can be modified by calling .chunk(). Differs from variable.chunks because it returns a mapping of dimensions to chunk shapes instead of a tuple of chunk shapes. See Also -------- Variable.chunk Variable.chunks xarray.unify_chunks rcSsi|]\}}||qSr8r8)rrcr8r8r9rfsz'Variable.chunksizes..N)r}rr"rrWr[rrr8r8r9 chunksizesUs zVariable.chunksizeszrint | Literal['auto'] | tuple[int, ...] | tuple[tuple[int, ...], ...] | Mapping[Any, None | int | tuple[int, ...]]z str | None)rrQlock inline_array chunks_kwargsr;c  sddlm}dkr&tjdtdittttt t fr.metac3s|]\}}||VqdSr)r)rns)rr8r9rsz!Variable.chunk..)rQrrr])Z dask.arrayrwarningswarn FutureWarningrDfloatrrrHlistr(rrrrr!rechunkrExplicitlyIndexedZ!ImplicitToExplicitIndexingAdapterrrer|rroZ from_arrayr) rrrQrrrdar[rr8)rrr9rlsF5       zVariable.chunkz np.ndarraycCsf|j}t|dr|}t|tdr.|}t|tdrB|j}t|tdrX|}t |}|S)z9Coerces wrapped data to numpy and returns a numpy.ndarrayrZcupyZpintsparse) r[r}rrDrrZ magnitudetodenserermrr8r8r9to_numpys  zVariable.to_numpycCs|j|dS)z>Coerces wrapped data into a numpy array, returning a Variable.r])rr-rr8r8r9as_numpyszVariable.as_numpycCsddl}|tjkr$t|j\}}nt|j|}|tkr>d}zt|d|}Wn"t k rxt |dYnX||j ||d}|j |dS)z. use sparse-array as backend. rNZcooZas_z is not a valid sparse formatrr])r+rrr{rcZ result_typer%rulowerAttributeErrorrJr[rir)r sparse_formatrr+rcZ as_sparser[r8r8r9 _as_sparses zVariable._as_sparsecCs*t|jdr|j|jdS|jddS)z8 Change backend from sparse to np.array r,r]Fr>)r}rrr,rGrr8r8r9 _to_denses zVariable._to_denseraisezMapping[Any, Any] | Noner.)rindexers missing_dimsindexers_kwargsr;c s:t|dt|j|tfdd|jD}||S)aReturn a new array indexed along the specified dimension(s). Parameters ---------- **indexers : {dim: indexer, ...} Keyword arguments with names matching dimensions and values given by integers, slice objects or arrays. missing_dims : {"raise", "warn", "ignore"}, default: "raise" What to do if dimensions that should be selected from are not present in the DataArray: - "raise": raise an exception - "warn": raise a warning, and ignore the missing dimensions - "ignore": ignore the missing dimensions Returns ------- obj : Array object A new Array with the selected data and dimensions. In general, the new variable's data will be a view of this variable's data, unless numpy fancy indexing was triggered by using an array indexer, in which case the data will be a copy. iselc3s|]}|tdVqdSrrrr6r8r9r(sz Variable.isel..)r(r'rWrH)rr6r7r8rr8r:r9r9s z Variable.iselcCs t||}|dd|DS)aGReturn a new object with squeezed data. Parameters ---------- dim : None or str or tuple of str, optional Selects a subset of the length one dimensions. If a dimension is selected with length greater than one, an error is raised. If None, all length one dimensions are squeezed. Returns ------- squeezed : same type as caller This object, but with with all or a subset of the dimensions of length 1 removed. See Also -------- numpy.squeeze cSsi|] }|dqS)rr8rrr8r8r9r@sz$Variable.squeeze..)rZget_squeeze_dimsr9)rrrWr8r8r9squeeze+s zVariable.squeezec s|}|dkr td| }n|dkr6t| d}ntd}|tdf||fj}|tjkrtt|j\}}n|j}tt||j |}|dkr|dfnd|ffdd|j D} t j | || d|d} t| r| |jj} |j| dS)Nrcsg|]}|krdnqS)rrr8r;rZdim_padr8r9rUsz+Variable._shift_one_dim..constantmodeconstant_valuesr])rrr[rrr{rcminabsrorWrepadrir!r(rr) rrcountraxisZkeepZ trimmed_datarcwidthpadsr[r8r>r9_shift_one_dimBs,  zVariable._shift_one_dimcKs6t||d}|}|D]\}}|j|||d}q|S)a Return a new Variable with shifted data. Parameters ---------- shifts : mapping of the form {dim: offset} Integer offset to shift along each of the given dimensions. Positive offsets shift to the right; negative offsets shift to the left. fill_value : scalar, optional Value to use for newly missing values **shifts_kwargs The keyword arguments form of ``shifts``. One of shifts or shifts_kwargs must be provided. Returns ------- shifted : Variable Variable with the same dimensions and attributes but shifted data. shiftr/)r(rrJ)rshiftsr shifts_kwargsresultrrFr8r8r9rKfs  zVariable.shiftz#Mapping[Any, int | tuple[int, int]] pad_optioncs6|r"fddt|j|jjDSfdd|jDS)Ncs(g|] \}}|kr||fn|qSr8r8)rrr!rOr8r9rsz6Variable._pad_options_dim_to_index..cs g|]}|krdn|qSr=r8r;rOr8r9rs)rrWr[ro)rrPfill_with_shaper8rOr9_pad_options_dim_to_indexs  z"Variable._pad_options_dim_to_indexr?z*Mapping[Any, int | tuple[int, int]] | Noner/z.rTrBrUrVFrGrAdefaultr)r(rrr{rcrDrSrRr[rornumbersNumberrerErirrrTrW)rrSrArTrBrUrVrrWrcrrZpad_width_by_indexZpad_option_kwargsrrr8r8r9rEsX6            z Variable.padcs||j;}|dkr:t| dtd| g}n tdg}fdd|D}t|}t|rz|jj}j |dS)Nrcs&g|]}tdf|fjqSr)rr[)ridxrGrr8r9rsz*Variable._roll_one_dim..r]) rrorr concatenater!r(r[rr)rrrFrarraysr[r8r`r9 _roll_one_dims   zVariable._roll_one_dimcKs2t||d}|}|D]\}}|||}q|S)aF Return a new Variable with rolld data. Parameters ---------- shifts : mapping of hashable to int Integer offset to roll along each of the given dimensions. Positive offsets roll to the right; negative offsets roll to the left. **shifts_kwargs The keyword arguments form of ``shifts``. One of shifts or shifts_kwargs must be provided. Returns ------- shifted : Variable Variable with the same dimensions and attributes but rolled data. roll)r(rrc)rrLrMrNrrFr8r8r9rds  z Variable.roll)r7zHashable | ellipsis)rWr7r;cGszt|dkr|jddd}ntt||j|}t|dksF||jkrR|jddS||}t|j|}|j ||dS)aReturn a new Variable object with transposed dimensions. Parameters ---------- *dims : Hashable, optional By default, reverse the dimensions. Otherwise, reorder the dimensions to this order. missing_dims : {"raise", "warn", "ignore"}, default: "raise" What to do if dimensions that should be selected from are not present in the Variable: - "raise": raise an exception - "warn": raise a warning, and ignore the missing dimensions - "ignore": ignore the missing dimensions Returns ------- transposed : Variable The returned object has transposed data and dimensions with the same attributes as the original. Notes ----- This operation returns a view of this variable's data. It is lazy for dask-backed Variables but not for numpy-backed Variables. See Also -------- numpy.transpose rNFr>r) rrWrHr*rGrrr transposer)rr7rWaxesr[r8r8r9rg(s"   zVariable.transposecCs|Sr)rgrr8r8r9TXsz Variable.Tcst|tr|g}|dkr*t|r*|}t|jt|}|rVtd|d|jt|jtfdd|D|j}|j|kr|j }nT|dk rt t ||tfdd|D}t |j |}n|j dt||j}t|||j|jdd }|j|S) a Return a new variable with given set of dimensions. This method might be used to attach new dimension(s) to variable. When possible, this operation does not copy this variable's data. Parameters ---------- dims : str or sequence of str or dict Dimensions to include on the new variable. If a dict, values are used to provide the sizes of new dimensions; otherwise, new dimensions are inserted with length 1. Returns ------- Variable Nznew dimensions z+ must be a superset of existing dimensions c3s|]}|kr|VqdSrr8r;) self_dimsr8r9r{sz$Variable.set_dims..c3s|]}|VqdSrr8r;)dims_mapr8r9rsrTrA)rDrrrrprRrWrJrHr[rSrrrrrVrFrrrg)rrWror7Z expanded_dimsZ expanded_dataZ tmp_shapeZ expanded_varr8)rkrjr9r\s4   zVariable.set_dimszlist[Hashable]r)rWnew_dimc stt|jks td||jkr2tdtdkrJ|jddSfdd|jD}|t}|j|}|jdt|d}t |j |}|jdt||f}t |||j |j d d S) Nzinvalid existing dimensions: Icannot create a new dimension with the same name as an existing dimensionrFr>csg|]}|kr|qSr8r8r;rWr8r9rsz(Variable._stack_once..)reTrA)rRrWrJrrGr'rgrorrnr[rFrr) rrWrl other_dims dim_order reordered new_shapenew_datanew_dimsr8rnr9 _stack_onces     zVariable._stack_oncecKs2t||d}|}|D]\}}|||}q|S)aB Stack any number of existing dimensions into a single new dimension. New dimensions will be added at the end, and the order of the data along each new dimension will be in contiguous (C) order. Parameters ---------- dimensions : mapping of hashable to tuple of hashable Mapping of form new_name=(dim1, dim2, ...) describing the names of new dimensions, and the existing dimensions that they replace. **dimensions_kwargs The keyword arguments form of ``dimensions``. One of dimensions or dimensions_kwargs must be provided. Returns ------- stacked : Variable Variable with the same attributes but stacked data. See Also -------- Variable.unstack stack)r(rru)r dimensionsdimensions_kwargsrNrlrWr8r8r9rvs  zVariable.stackzMapping[Any, int])rWold_dimr;c st|}t|}|jkr0tdt||jrHtdt||j krdtdfdd|jD}|g}|j |}|j dt ||}|j |} |jdt ||} t| | |j|jddS) z Unstacks the variable without needing an index. Unlike `_unstack_once`, this function requires the existing dimension to contain the full product of the new dimensions. zinvalid existing dimension: rmzOthe product of the new dimension sizes must equal the size of the old dimensioncsg|]}|kr|qSr8r8r;ryr8r9rsz/Variable._unstack_once_full..NTrA)rHkeysrprWrJrR intersectionmathprodrrgrorr[rnrFrr) rrWry new_dim_names new_dim_sizesrorprqrrrsrtr8rzr9_unstack_once_fulls&      zVariable._unstack_once_fullz pd.MultiIndex)rrr+r;cs~|d}dd|jD}|j}|j}fdd|jD} tt|jdt| |} |jdt| |} |t j krt | t |jk} | rt |j\} }q|j} t | }n|j} |rPddlm}t|j}|jdkr|}n8tjd d|jdd D}t||}td d |}|tt|j|j| || |jd }n tj|j|| | d}||d|<|j| |dS)z Unstacks this variable given an index to unstack and the name of the dimension to which the index refers. .cSsg|] }|jqSr8)r)rZlevr8r8r9rsz*Variable._unstack_once..csg|]}|kr|qSr8r8r;rr8r9rsNr)COOr@cSsg|] }t|qSr8)r)rr"r8r8r9rsrecSsttj|Sr)r' itertoolschain)xr8r8r9z(Variable._unstack_once..)Zcoordsr[rrosorted)rrorcr).) rglevelsnamescodesrWrHr'rorrrr}r~r{rcrr+rrrVrproductmaprerrir[rirlZis_monotonic_increasingZ full_liker)rrrrr+rqrrrrorrrtZis_missing_valuesrcrrindexesrZ tuple_indexesr[r8rr9 _unstack_oncesJ         zVariable._unstack_oncecKs2t||d}|}|D]\}}|||}q|S)a; Unstack an existing dimension into multiple new dimensions. New dimensions will be added at the end, and the order of the data along each new dimension will be in contiguous (C) order. Note that unlike ``DataArray.unstack`` and ``Dataset.unstack``, this method requires the existing dimension to contain the full product of the new dimensions. Parameters ---------- dimensions : mapping of hashable to mapping of hashable to int Mapping of the form old_dim={dim1: size1, ...} describing the names of existing dimensions, and the new dimensions and sizes that they map to. **dimensions_kwargs The keyword arguments form of ``dimensions``. One of dimensions or dimensions_kwargs must be provided. Returns ------- unstacked : Variable Variable with the same attributes but unstacked data. See Also -------- Variable.stack DataArray.unstack Dataset.unstack unstack)r(rr)rrwrxrNryrWr8r8r9r.s zVariable.unstackcCs t||Sr)rfillnarr8r8r9rTszVariable.fillnacCst|||Sr)rZ where_method)rZcondotherr8r8r9rWszVariable.wherecCs ddlm}|tj|||ddS)a Return an array whose values are limited to ``[min, max]``. At least one of max or min must be given. Refer to `numpy.clip` for full documentation. See Also -------- numpy.clip : equivalent function rrr)r)rrreclip)rrCmaxrr8r8r9rZs z Variable.clipzCallable[..., Any]r-zint | Sequence[int] | None)funcrrGrkeepdimsr;c s|dkr d}|dk r$|dk r$td|dk r6||}tbtjddtd|dk rt|trvt|dkrv|d}||j fd |i|}n||j f|}W5QRXt |d d |j kr|j }n|dkrt |jnt||j|r8tfd d t |jD} t |d ddkr(t|| }n|| }|j }ntfdd t|j D}|dkrhtdd}|rt|jnd} t||| dS)aReduce this array by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `func(x, axis=axis, **kwargs)` to return the result of reducing an np.ndarray over an integer valued axis. dim : "...", str, Iterable of Hashable or None, optional Dimension(s) over which to apply `func`. By default `func` is applied over all dimensions. axis : int or Sequence of int, optional Axis(es) over which to apply `func`. Only one of the 'dim' and 'axis' arguments can be supplied. If neither are supplied, then the reduction is calculated over the flattened array (by calling `func(x)` without an axis argument). keep_attrs : bool, optional If True, the variable's attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new object will be returned without attributes. keepdims : bool, default: False If True, the dimensions which are reduced are left in the result as dimensions of size one **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : Array Array with summarized data and the indicated dimension(s) removed. .Nz-cannot supply both 'axis' and 'dim' argumentsignorezMean of empty slicerr@rrGror8c3s&|]}|krtjntddVqdSr)rerrrZ removed_axesr8r9rsz"Variable.reduce..c3s|]\}}|kr|VqdSrr8)rr!Zadimrr8r9rsFrZr\)rJrr#catch_warningsfilterwarningsRuntimeWarningrDrHrr[rurorWrrVre atleast_1dZ asanyarrayrrrrF) rrrrGrrrr[rWrrr8rr9reduceisJ)       zVariable.reduce concat_dimoverridecCsddlm}t|ts|j\}t|}|d}dd|D}||jkr||} |j} tj|| d} |dk rt t |} tj | | | d} nd} |f|j} tj || d} |dd|D|d} t|j}|s|D]0}|j|jkrtd t|jd t|jq|| | | |S) aPConcatenate variables along a new or existing dimension. Parameters ---------- variables : iterable of Variable Arrays to stack together. Each variable is expected to have matching dimensions and shape except for along the stacked dimension. dim : str or DataArray, optional Name of the dimension to stack along. This can either be a new dimension name, in which case it is added along axis=0, or an existing dimension name, in which case the location of the dimension is unchanged. Where to insert the new dimension is determined by the first variable. positions : None or list of array-like, optional List of integer arrays which specifies the integer positions to which to assign each dataset along the concatenated dimension. If not supplied, objects are concatenated in the provided order. shortcut : bool, optional This option is used internally to speed-up groupby operations. If `shortcut` is True, some checks of internal consistency between arrays to concatenate are skipped. combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", "override"}, default: "override" String indicating how to combine attrs of the objects being merged: - "drop": empty attrs on returned Dataset. - "identical": all attrs must be the same on every object. - "no_conflicts": attrs from all objects are combined, any that have the same name must also have the same value. - "drop_conflicts": attrs from all objects are combined, any that have the same name but different values are dropped. - "override": skip comparing and copy attrs from the first dataset to the result. Returns ------- stacked : Variable Concatenated Variable formed by stacking all the supplied variables along the given dimension. r merge_attrscSsg|] }|jqSr8r]rrr8r8r9rsz#Variable.concat..rGNcSsg|] }|jqSr8r\rvarr8r8r9rs combine_attrszVariable has dimensions z# but first Variable has dimensions )xarray.core.mergerrDrrWr'rrrarinverse_permutationretakervrSrrJ)clsrr positionsshortcutrr first_varrbrGrWr[rrrrr8r8r9concats82        zVariable.concatc CsTt|d|}z(|j|jko2|j|jkp2||j|jWSttfk rNYdSXdS)aOTrue if two Variables have the same dimensions and values; otherwise False. Variables can still be equal (like pandas objects) if they have NaN values in the same locations. This method is necessary because `v1 == v2` for Variables does element-wise comparisons (like numpy.ndarrays). rEFN)rurWrr[rIr1rrequivr8r8r9equalss  zVariable.equalsc Cs<zt||\}}Wnttfk r,YdSX|j||dS)zTrue if two Variables have the values after being broadcast against each other; otherwise False. Variables can still be equal (like pandas objects) if they have NaN values in the same locations. Fr)broadcast_variablesrJr1rrr8r8r9broadcast_equals1s zVariable.broadcast_equalsc Cs@z t|j|jo|j||dWSttfk r:YdSXdS)z(Like equals, but also checks attributes.rFN)rZ dict_equivrrrIr1rr8r8r9 identical>szVariable.identicalcCs|j||dS)zTrue if the intersection of two Variable's non-null data is equal; otherwise false. Variables can thus still be equal if there are locations where either, or both, contain NaN values. r)rrr8r8r9 no_conflictsGszVariable.no_conflictslinearr zstr | Sequence[Hashable] | Noner1zQuantileMethods | None)qrmethodrskipna interpolationr;c szddlm}|dk r4tdt|dkr0td|}|sL|dkrT|jjdkrTtj ntj |dkrlt dd }t |}ttj|tjd }|dkr|j}t |r|g}fd d } td d t|dd } ttjtdkr|| |d} n&|dkr td|d|| |d} || ||gt|dggtjgtdt|idd| d } | dd} |rh| d} |rv|j| _| S)aM Compute the qth quantile of the data along the specified dimension. Returns the qth quantiles(s) of the array elements. Parameters ---------- q : float or sequence of float Quantile to compute, which must be between 0 and 1 inclusive. dim : str or sequence of str, optional Dimension(s) over which to apply quantile. method : str, default: "linear" This optional parameter specifies the interpolation method to use when the desired quantile lies between two data points. The options sorted by their R type as summarized in the H&F paper [1]_ are: 1. "inverted_cdf" (*) 2. "averaged_inverted_cdf" (*) 3. "closest_observation" (*) 4. "interpolated_inverted_cdf" (*) 5. "hazen" (*) 6. "weibull" (*) 7. "linear" (default) 8. "median_unbiased" (*) 9. "normal_unbiased" (*) The first three methods are discontiuous. The following discontinuous variations of the default "linear" (7.) option are also available: * "lower" * "higher" * "midpoint" * "nearest" See :py:func:`numpy.quantile` or [1]_ for details. The "method" argument was previously called "interpolation", renamed in accordance with numpy version 1.22.0. (*) These methods require numpy version 1.22 or newer. keep_attrs : bool, optional If True, the variable's attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new object will be returned without attributes. skipna : bool, optional If True, skip missing values (as marked by NaN). By default, only skips missing values for float dtypes; other dtypes either do not have a sentinel missing value (int) or skipna=True has not been implemented (object, datetime64 or timedelta64). Returns ------- quantiles : Variable If `q` is a single quantile, then the result is a scalar. If multiple percentiles are given, first axis of the result corresponds to the quantile and a quantile dimension is added to the return array. The other dimensions are the dimensions that remain after the reduction of the array. See Also -------- numpy.nanquantile, pandas.Series.quantile, Dataset.quantile DataArray.quantile References ---------- .. [1] R. J. Hyndman and Y. Fan, "Sample quantiles in statistical packages," The American Statistician, 50(4), pp. 361-365, 1996 rrNzAThe `interpolation` argument to quantile was renamed to `method`.rz.Cannot pass interpolation and method keywords!ZcfOFrZrtcst|f|ddS)Nrre)rer)ZnparZ_quantile_funcr8r9_wrappersz#Variable.quantile.._wrapperrer@z1.22.0)rrGr)rr0ZhigherZmidpointZnearestzInterpolation method 'z-' requires numpy >= 1.22 or is not supported.)rrGrquantile)Z output_sizesZ parallelized)Zinput_core_dimsZ exclude_dimsZoutput_core_dimsZ output_dtypesZdask_gufunc_kwargsrr.)rrr#r$r%rIrcrdreZ nanquantilerrrrMrrmZfloat64rWrrr __version__rJrRrSrgr<rr) rrrrrrrrZscalarrrGrrNr8rr9rPs\P          zVariable.quantilec Cstdstdddl}|j}t|r0tdn t|tjsPtdt |d| |}|j j dkrl|j n|j}|||d }|rtjt||d d }||}t|j|S) aRanks the data. Equal values are assigned a rank that is the average of the ranks that would have been otherwise assigned to all of the values within that set. Ranks begin at 1, not 0. If `pct`, computes percentage ranks. NaNs in the input array are returned as NaNs. The `bottleneck` library is required. Parameters ---------- dim : str Dimension over which to compute rank. pct : bool, optional If True, compute percentage ranks, otherwise compute integer ranks. Returns ------- ranked : Variable See Also -------- Dataset.rank, DataArray.rank Zuse_bottleneckz`rank requires bottleneck to be enabled. Call `xr.set_options(use_bottleneck=True)` to enable it.rNzzrank does not work for arrays stored as dask arrays. Load the data via .compute() or .load() prior to calling this method.zrank is not implemented for z objects.frT)rGr)r RuntimeErrorZ bottleneckr[r!rIrDrer|rTrrcrdZ nanrankdataZrankdatasumisnanrFrW) rrZpctZbnr[rGrZrankedrFr8r8r9ranks&   z Variable.rankc s|tjkr*tj\}}j|dd}n j}}t|rtdddg|||gD](\}} t| sTtd|d| dqT|g}t |} t|r|g| }t|r|g| }t|r|g| }t |t |kst |t |kst |t |krtd |d |d |d |d i} t|||D]D\} } }|r^| d}| d|}||f| | <n| ddf| | <q,|j | d|d}fdd|D}j t |}t |tj|j||dS)a! Make a rolling_window along dim and add a new_dim to the last place. Parameters ---------- dim : str Dimension over which to compute rolling_window. For nd-rolling, should be list of dimensions. window : int Window size of the rolling For nd-rolling, should be list of integers. window_dim : str New name of the window dimension. For nd-rolling, should be list of strings. center : bool, default: False If True, pad fill_value for both ends. Otherwise, pad in the head of the axis. fill_value value to be filled. Returns ------- Variable that is a view of the original array with a added dimension of size w. The return dim: self.dims + (window_dim, ) The return shape: self.shape + (window, ) Examples -------- >>> v = Variable(("a", "b"), np.arange(8).reshape((2, 4))) >>> v.rolling_window("b", 3, "window_dim") array([[[nan, nan, 0.], [nan, 0., 1.], [ 0., 1., 2.], [ 1., 2., 3.]], [[nan, nan, 4.], [nan, 4., 5.], [ 4., 5., 6.], [ 5., 6., 7.]]]) >>> v.rolling_window("b", 3, "window_dim", center=True) array([[[nan, 0., 1.], [ 0., 1., 2.], [ 1., 2., 3.], [ 2., 3., nan]], [[nan, 4., 5.], [ 4., 5., 6.], [ 5., 6., 7.], [ 6., 7., nan]]]) FrYwindow window_dimcenterz Expected =z to be a scalar like 'dim'.zR'dim', 'window', 'window_dim', and 'center' must be the same length. Received dim=z , window=z , window_dim=z , and center=.rfr@rr?r@csg|]}|qSr8rr;rr8r9r} sz+Variable.rolling_window..)Z window_shaperG)rrr{rcrirrMrrJrrErWrHrFrZsliding_window_viewr[)rrrrrrrcrrQargZnrollrIrwincentstartendZpaddedrGrtr8rr9rolling_window sb9           zVariable.rolling_windowexactleftc  sfdd|D}|dkr(tdd}|r4j}nd}|sHj|dS|||\}} t|tr|} tt| d}|dkrt | dj||fd| i||d S) z+ Apply reduction function. cs i|]\}}|jkr||qSr8rnrrr8r9r s z$Variable.coarsen..NTrZr\z is not a valid method.rG)r[r) rrrrcoarsen_reshaperDrrur NameError) rwindowsrboundarysiderrrZreshapedrhrQr8rr9coarsen s    zVariable.coarsencsbts fddDts@fddDfddDfddDD]$\}}|dkrttd|d|qt|}D]"\}}|j||}t||}|d kr|||krtd |d |d q|d krT|dkr2||t d||i}n |||} ||t | di}q|dkr|||} | dkr| |7} |dkr|d| fi} n || dfi} |j | dd}qt d |qg} g} d}t |jD]j\}}|kr:|j|}| t||| ||d7}| ||n| |j|q|j| t| fS)z8 Construct a reshaped-array for coarsen csi|] }|qSr8r8r;)rr8r9r sz,Variable.coarsen_reshape..csi|] }|qSr8r8r;)rr8r9r scsi|]\}}|kr||qSr8r8rrr8r9r scsi|]\}}|kr||qSr8r8rrr8r9r srzwindow must be > 0. Given z for dimension rz&Could not coarsen a dimension of size z with window z9 and boundary='exact'. Try a different 'boundary' option.ZtrimrNrEr?)rAzE{} is invalid for boundary. Valid option is 'exact', 'trim' and 'pad'r@)rrr{rrJroZ _get_axis_numrr9rrErIrLrrWrr[rnrH)rrrrrrrErr!ZexcessrErSrorhZ axis_countrr8)rrrr9r sd           zVariable.coarsen_reshape)rcCs0ddlm}|dkrtdd}|tj|d|dS)aTest each value in the array for whether it is a missing value. Returns ------- isnull : Variable Same type and shape as object, but the dtype of the data is bool. See Also -------- pandas.isnull Examples -------- >>> var = xr.Variable("x", [1, np.nan, 3]) >>> var array([ 1., nan, 3.]) >>> var.isnull() array([False, True, False]) rrNFrZrrr)rrrrisnullrrrr8r8r9r s  zVariable.isnullcCs0ddlm}|dkrtdd}|tj|d|dS)aTest each value in the array for whether it is not a missing value. Returns ------- notnull : Variable Same type and shape as object, but the dtype of the data is bool. See Also -------- pandas.notnull Examples -------- >>> var = xr.Variable("x", [1, np.nan, 3]) >>> var array([ 1., nan, 3.]) >>> var.notnull() array([ True, False, True]) rrNFrZrr)rrrrnotnullrr8r8r9r s  zVariable.notnullcCs|j|jjdS)zn The real part of the variable. See Also -------- numpy.ndarray.real r])rr[realrr8r8r9r) s z Variable.realcCs|j|jjdS)zs The imaginary part of the variable. See Also -------- numpy.ndarray.imag r])rr[imagrr8r8r9r4 s z Variable.imagcCs t|j|Sr)rFrW)rrYcontextr8r8r9__array_wrap__? szVariable.__array_wrap__c Osj|dd}|dkrtdd}tjdd6|||jf||}|rP|j|_|W5QRSQRXdS)NrTrZrr)poprreerrstaterr[r)rrrrrrNr8r8r9 _unary_opB s  zVariable._unary_opc Cst|tjtjfrtS|r>tt|t|r>t||\}}}nt||\}}}tdd}|rb|j nd}t j dd|s|||n|||} W5QRXt || |d} | S)NFrZrrr\) rDxrr=DatasetNotImplemented issubclassrT_broadcast_compat_datarrrerrF) rrrZ reflexive other_data self_datarWrrrsrNr8r8r9 _binary_opL s  zVariable._binary_opc Cs^t|tjrtdt||\}}}||jkr6tdtjdd||||_ W5QRX|S)Nz+cannot add a Dataset to a Variable in-placez0dimensions cannot change for in-place operationsrr) rDrrrIrrWrJrerrp)rrrrrrWr8r8r9_inplace_binary_op\ s  zVariable._inplace_binary_opcCs&t|j|||}t||j||jS)zuA (private) method to convert datetime array to numeric dtype See duck_array_ops.datetime_to_numeric )rZdatetime_to_numericr[rTrWr)roffsetZ datetime_unitrcZ numeric_arrayr8r8r9 _to_numericf szVariable._to_numericrz int | Nonez#Variable | dict[Hashable, Variable]) argminmaxrrGrrr;cs4|dkr |dkr tjdtddtt|}|dkr8j}|dks\|dk s\t|tr\t|trpj |||||dSd}d}|jkrd |}|d7}qx ||i} | jdd t fd d |D} | j |d |d } t | j | } fddt|| D} |dkrtdd}|r0| D]}j|_q | S)zApply argmin or argmax over one or more dimensions, returning the result as a dict of DataArray that can be passed directly to isel. NzBehaviour of argmin/argmax with neither dim nor axis argument will change to return a dict of indices of each dimension. To get a single, flat index, please use np.argmin(da.data) or np.argmax(da.data) instead of da.argmin() or da.argmax().) stacklevel.)rrGrrZ_unravel_argminmax_dim_0r@Z_unravel_argminmax_dim_rec3s|]}j|VqdSr)rr;rr8r9r sz.Variable._unravel_argminmax..)rGrcsi|]\}}|t|dqS)rr)rrr) result_dimsr8r9r sz/Variable._unravel_argminmax..FrZ)r#r$DeprecationWarningrurrWrDr rrrvrHZ unravel_indexr[rrrpr)rrrrGrrZargminmax_funcZ newdimnamerFZstackedZ reduce_shapeZresult_flat_indicesZresult_unravelled_indicesrNrr8)rrr9_unravel_argminmaxo s\          zVariable._unravel_argminmax)rrGrrr;cCs|d||||S)aIndex or indices of the minimum of the Variable over one or more dimensions. If a sequence is passed to 'dim', then result returned as dict of Variables, which can be passed directly to isel(). If a single str is passed to 'dim' then returns a Variable with dtype int. If there are multiple minima, the indices of the first one found will be returned. Parameters ---------- dim : "...", str, Iterable of Hashable or None, optional The dimensions over which to find the minimum. By default, finds minimum over all dimensions - for now returning an int for backward compatibility, but this is deprecated, in future will return a dict with indices for all dimensions; to return a dict with all dimensions now, pass '...'. axis : int, optional Axis over which to apply `argmin`. Only one of the 'dim' and 'axis' arguments can be supplied. keep_attrs : bool, optional If True, the attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new object will be returned without attributes. skipna : bool, optional If True, skip missing values (as marked by NaN). By default, only skips missing values for float dtypes; other dtypes either do not have a sentinel missing value (int) or skipna=True has not been implemented (object, datetime64 or timedelta64). Returns ------- result : Variable or dict of Variable See Also -------- DataArray.argmin, DataArray.idxmin argminrrrrGrrr8r8r9r s+zVariable.argmincCs|d||||S)aIndex or indices of the maximum of the Variable over one or more dimensions. If a sequence is passed to 'dim', then result returned as dict of Variables, which can be passed directly to isel(). If a single str is passed to 'dim' then returns a Variable with dtype int. If there are multiple maxima, the indices of the first one found will be returned. Parameters ---------- dim : "...", str, Iterable of Hashable or None, optional The dimensions over which to find the maximum. By default, finds maximum over all dimensions - for now returning an int for backward compatibility, but this is deprecated, in future will return a dict with indices for all dimensions; to return a dict with all dimensions now, pass '...'. axis : int, optional Axis over which to apply `argmin`. Only one of the 'dim' and 'axis' arguments can be supplied. keep_attrs : bool, optional If True, the attributes (`attrs`) will be copied from the original object to the new one. If False (default), the new object will be returned without attributes. skipna : bool, optional If True, skip missing values (as marked by NaN). By default, only skips missing values for float dtypes; other dtypes either do not have a sentinel missing value (int) or skipna=True has not been implemented (object, datetime64 or timedelta64). Returns ------- result : Variable or dict of Variable See Also -------- DataArray.argmax, DataArray.idxmax argmaxrrr8r8r9r s+zVariable.argmax)NNF)TF)TN)TNN)N)Nr5)N)F)Nr?NNNNN)N)N)N)N)NN)NNNF)rNFr)NrNNN)F)rrN)N)N)N)F)NNNN)NNNN)tr4r5r6r7 __slots__rpropertyrcrorrr[setterrirrrrrrrrrrrrprraliasrrXrrrrrWrrrrrrrrrrrrrr rrrGr r%rrr__hash__rrrrFZ_array_counterrr-r.r3r4r9r<rJrKrRrErcrdrgrirrurvrrrrrrr classmethodrrZ array_equivrrrZarray_notnull_equivrrrrrrrrrrrrrrr&rrrrr8r8r8r9rFBsr      K        :8( >#  g # $l 0 1 )D & ] X    6 q C""     $H"/rFcsBeZdZdZdZd<fdd ZddZd d Zej j d d Z ej j d dZ idddfddZ e e fddZddZddZddZed=ddZd>ddd d!d"Zd?fd#d$ Zd%d&Zdd'd(d)Zeed*Zd+d'd,d-Zd+d'd.d/Zed0d'd1d2Zd3d4Zed5d'd6d7Z e j d8d'd9d7Z d:d;Z!Z"S)@rPafWrapper for accommodating a pandas.Index in an xarray.Variable. IndexVariable preserve loaded values in the form of a pandas.Index instead of a NumPy array. Hence, their values are immutable and must always be one- dimensional. They also have a name property, which is the name of their sole dimension unless another name is given. r8NFcsNt||||||jdkr2tt|jdt|jtsJt|j|_dS)Nr@z objects must be 1-dimensional) superrrVrJrTr4rDrrrrKr8r9r s   zIndexVariable.__init__cCs(ddlm}|t||j|jj|jfSr)rrrTrrrrrr8r8r9r& s zIndexVariable.__dask_tokenize__cCs|Srr8rr8r8r9r, szIndexVariable.loadcCstd|jddS)NzQCannot assign to the .data attribute of dimension coordinate a.k.a IndexVariable ]. Please use DataArray.assign_coords, Dataset.assign_coords or Dataset.assign as appropriate.rJrQrr8r8r9r[1 s zIndexVariable.datacCstd|jddS)NzSCannot assign to the .values attribute of dimension coordinate a.k.a IndexVariable rrrr8r8r9rp8 s zIndexVariable.valuescCs |jddSrrY)rrrQrrr8r8r9r? szIndexVariable.chunkcCs |jddSrrY)rr2rr8r8r9r3C szIndexVariable._as_sparsecCs |jddSrrYrr8r8r9r4G szIndexVariable._to_densecCs4t|dddkr"t|||j|jS|j||dSdS)NrVrr@r)rurFrrrrr8r8r9rK sz'IndexVariable._finalize_indexing_resultcCstt|jddS)Nz values cannot be modified)rIrTr4)rrrsr8r8r9r R szIndexVariable.__setitem__rrc sddlm}t|ts|j\}t|}|d}tfdd|DrLtddd|D}|sdg} n8|d|dd } |d k rt t |} | | } t| |} |d d|D|d } |s|D]} | j|jkrtd qĈ|j| | S) zSpecialized version of Variable.concat for IndexVariable objects. This exists because we want to avoid converting Index objects to NumPy arrays, if possible. rrc3s|]}t| VqdSr)rDrrr8r9rk sz'IndexVariable.concat..zOIndexVariable.concat requires that all input variables be IndexVariable objectscSsg|] }|jjqSr8)rrrr8r8r9rq sz(IndexVariable.concat..r@NcSsg|] }|jqSr8r\rr8r8r9r srzinconsistent dimensions)rrrDrrWr'rzrIrrrrerarr,rJ) rrrrrrrrrr[rrrr8rr9rU s4       zIndexVariable.concatTrr r cCs|dkr|jj|d}n(t|}|j|jkr@td|j|j|rPt|jn t|j}|rlt|jn t|j}|j |||dS)aKReturns a copy of this object. `deep` is ignored since data is stored in the form of pandas.Index, which is already immutable. Dimensions, attributes and encodings are always copied. Use `data` to create a new object with the same structure as original but entirely new data. Parameters ---------- deep : bool, default: True Deep is ignored when data is given. Whether the data array is loaded into memory and copied onto the new object. Default is True. data : array_like, optional Data to use in the new object. Must have same shape as original. Returns ------- object : Variable New object with dimensions, attributes, encodings, and optionally data copied from original. Nr>rr) rrGrUrorJrLrrrr)rr?r[rrrr8r8r9rG s zIndexVariable.copyc sZ|dk rt||St|d|}z|j|jko8||WSttfk rTYdSXdS)NrEF)rrrurW _data_equalsrIr1rrr8r9r s zIndexVariable.equalscCs||Sr)rr)rrr8r8r9r szIndexVariable._data_equalsr:cCs |jddS)rFr>rYrr8r8r9rX szIndexVariable.to_index_variablerrcsVjdkstjj}t|tjrFfddt|jD}| |}n | j }|S)Nr@cs(g|] \}}|p"jdd|qS)rZ_level_rn)rrrQrr8r9r sz+IndexVariable._to_index..) rVAssertionErrorrrrDrN MultiIndexrrZ set_namesrQ)rrZvalid_level_namesr8rr9r s    zIndexVariable._to_indexcCs0|}t|jdd}|dk r(||S|SdS)rlevelN)rrurget_level_values)rrr r8r8r9r s  zIndexVariable.to_indexzlist[str] | NonecCs"|}t|tjr|jSdSdS)z_Return MultiIndex level names or None if this IndexVariable has no MultiIndex. N)rrDrNr r)rrr8r8r9 level_names s zIndexVariable.level_namescCs:|jdkrtd|jd|}t||j||S)z9Return a new IndexVariable from a given MultiIndex level.NzIndexVariable z has no MultiIndex)r rJrQrrTrWr )rr rr8r8r9get_level_variable s z IndexVariable.get_level_variablercCs |jdS)Nrrnrr8r8r9rQ szIndexVariable.namer cCs tddS)Nz,cannot modify name of IndexVariable in-place)r1rr8r8r9rQ scCs tddS)NzHValues of an IndexVariable are immutable and can not be modified inplace)rI)rrrr8r8r9r sz IndexVariable._inplace_binary_op)NNF)rNFr)TN)N)#r4r5r6r7rrrrrFr[rrprr%r3r4rr rrrGrrrXrrrrrrr r rQr __classcell__r8r8rr9rP sF     3(    rP CoordinatecCsi}|D]}|j}tt|t|kr8tdt|t||jD]B\}}||kr^|||<qD|||krDtd|d|||fqDq|S)Nz1broadcasting cannot handle duplicate dimensions: zLoperands cannot be broadcast together with mismatched lengths for dimension z: )rWrrRrJr'rro)rZall_dimsrZvar_dimsrr"r8r8r9 _unified_dims s   rcs"tt|tfdd|DS)zCreate broadcast compatible variables, with the same dimensions. Unlike the result of broadcast_variables(), some variables may have dimensions of size 1 instead of the size of the broadcast dimension. c3s&|]}|jkr|n|VqdSrrWrrrnr8r9r# sz._broadcast_compat_variables..)rHrrr8rnr9r s rztuple[Variable, ...])rr;cs(t|ttfdd|DS)aGiven any number of variables, return variables with matching dimensions and broadcast data. The data on the returned variables will be a view of the data on the corresponding original arrays, but dimensions will be reordered and inserted so that both broadcast arrays have the same dimensions. The new dimensions are sorted in order of appearance in the first variable's dimensions followed by the second variable's dimensions. c3s&|]}|jkr|n|VqdSrrrrkZ dims_tupler8r9r2 sz&broadcast_variables..)rrHrr8rr9r& s rcsRtfdddDr8t|\}}|j}|j}|j}n|j}}|j}|||fS)Nc3s|]}t|VqdSr)r})rattrrr8r9r8 sz)_broadcast_compat_data..)rWr[ror)rrr[rW)rrZnew_selfZ new_otherrrrWr8rr9r7 srrrcCsBt|}tdd|Dr,t|||||St|||||SdS)aConcatenate variables along a new or existing dimension. Parameters ---------- variables : iterable of Variable Arrays to stack together. Each variable is expected to have matching dimensions and shape except for along the stacked dimension. dim : str or DataArray, optional Name of the dimension to stack along. This can either be a new dimension name, in which case it is added along axis=0, or an existing dimension name, in which case the location of the dimension is unchanged. Where to insert the new dimension is determined by the first variable. positions : None or list of array-like, optional List of integer arrays which specifies the integer positions to which to assign each dataset along the concatenated dimension. If not supplied, objects are concatenated in the provided order. shortcut : bool, optional This option is used internally to speed-up groupby operations. If `shortcut` is True, some checks of internal consistency between arrays to concatenate are skipped. combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", "override"}, default: "override" String indicating how to combine attrs of the objects being merged: - "drop": empty attrs on returned Dataset. - "identical": all attrs must be the same on every object. - "no_conflicts": attrs from all objects are combined, any that have the same name must also have the same value. - "drop_conflicts": attrs from all objects are combined, any that have the same name but different values are dropped. - "override": skip comparing and copy attrs from the first dataset to the result. Returns ------- stacked : Variable Concatenated Variable formed by stacking all the supplied variables along the given dimension. css|]}t|tVqdSr)rDrPrr8r8r9rw szconcat..N)r'rrPrrF)rrrrrr8r8r9rF s0rzMapping[Any, Variable]zdict[Hashable, int]c Csi}i}dd|D}|D]\}}t|j|jD]p\}}||krXtd|d||krr|||<|||<q8|||kr8td|d|d|d||d| q8q"|S) zCalculate the dimensions corresponding to a set of variables. Returns dictionary mapping from dimension names to sizes. Raises ValueError if any of the dimension sizes conflict. cSsh|]\}}|js|qSr8rnrr8r8r9 sz'calculate_dimensions..z dimension z$ already exists as a scalar variablez conflicting sizes for dimension z : length z on z and length )rrrWrorJ)rrWZ last_usedZ scalar_varsrrrrr8r8r9calculate_dimensions} s"   $r)N)F)rNFr)b __future__rrGrr}r]r#rartypingrrrrrr r r r ZnumpyreZpandasrNZ numpy.typingr Zpackaging.versionrZxarrayrZ xarray.corerrrrrrrZxarray.core.arithmeticrZxarray.core.commonrZxarray.core.indexingrrrrrZxarray.core.optionsrrZxarray.core.pycompatrr r!Zxarray.core.utilsr"r#r$r%r&r'r(r)r*r+r,r)rOrvrrZxarray.core.typesr-r.r/r0r1r2rgrJr3r\r^rjrqrrrUrrFrPrrrrrrrrr8r8r8r9s  ,   $  4   U  <au   7