U Cv f@c@s~ddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#Z$ddl%Z&dd l'm(Z(m)Z)dd l*m+Z+m,Z,dd l-m.Z.dd l-m/Z0dd l-m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7ddl8m9Z9m:Z:m;Z;ddlm?Z?m@Z@mAZAddlBmCZCddlDmEZEmFZFddlGmHZHddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZVddlWmXZXmYZYmZZZm[Z[ddl\m]Z]ddl^m_Z_m`Z`ddlambZbmcZcddldmeZemfZfddlgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpmqZqmrZrmsZsddltmuZumvZvmwZwmxZxmyZyddlzm{Z{erddl|m}Z}dd l~mZmZdd!lmZmZdd"lDmZdd#lmZdd$lmZdd%lWmZdd&lmZdd'lmZmZdd(ldmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd)lmZzdd*lmZWnek rdZYnXzdd+lmZWnek rdZYnXd,d-d.d/d0d1d2d3d4d5d6d7d8d9gZd\d:d;dd?Zd]dAdBdCdDdEdFZdGdHZd^dKdLZdMdNdOdPdQZdRdSZdTdUZGdVdWdWeedXfZGdYdZdZeefZGd[dNdNe?e7e=eedXfZdS)_) annotationsN) defaultdict)escape)Number) methodcaller)PathLike)IO TYPE_CHECKINGAnyCallable CollectionGenericHashableIterableIteratorLiteralMappingMutableMappingSequencecastoverload)convert_calendarinterp_calendar) CFTimeIndex_parse_array_of_cftime_strings) alignment)dtypes)duck_array_ops formattingformatting_htmlopsutils)DatasetAggregations)_broadcast_helper%_get_broadcast_dims_map_common_coordsalign)DatasetArithmetic)DataWithCoords_contains_datetime_like_objectsget_chunksizes unify_chunks)DatasetCoordinatesassert_coordinate_consistent)datetime_to_numeric) IndexIndexes PandasIndexPandasMultiIndexassert_no_index_corruptedcreate_default_index_implicitfilter_indexes_from_coords isel_indexesremove_unused_levels_categories roll_indexes)is_fancy_indexermap_index_queries)dataset_merge_methoddataset_update_methodmerge_coordinates_without_alignmerge_data_and_coords)get_clean_interp_index)OPTIONS_get_keep_attrs) array_typeis_duck_dask_array)QuantileMethods T_Dataset) DefaultFrozenHybridMappingProxy OrderedSet_defaultdecode_numpy_dict_valuesdrop_dims_from_indexerseither_dict_or_kwargs infix_dims is_dict_like is_scalarmaybe_wrap_array) IndexVariableVariable as_variablebroadcast_variablescalculate_dimensions)DatasetPlotAccessor) ArrayLike)AbstractDataStore ZarrStore)T_NetcdfEngine T_NetcdfTypes) Coordinates DataArrayDatasetGroupBy)CoercibleMappingDatasetResample)DatasetCoarsenDatasetRolling) CFCalendarCoarsenBoundaryOptionsCombineAttrsOptions CompatOptions DatetimeLikeDatetimeUnitOptionsDims ErrorOptionsErrorOptionsWithWarn InterpOptions JoinOptionsPadModeOptionsPadReflectOptionsQueryEngineOptionsQueryParserOptionsReindexMethodOptions SideOptionsT_XarrayDatasetWeighted)Delayed) DataFrameyearmonthdayhourminutesecond microsecondZ nanoseconddatetimeZ dayofyearZ weekofyearZ dayofweekZquarterrMapping | Nonez#tuple[Hashable, Hashable, Variable])key dim_sizesreturnc Csddlm}|dkri}||krLtjt|||d}t|f|}|||fSt|ts^t|| dd}t |dkr~t||\}}||} t | r|| } t | j |j}n t | |j}t| j|} ||| fS)ziGet a virtual variable (e.g., 'time.year') from a dict of xarray.Variable objects (if possible) rr^Nname.)xarray.core.dataarrayr_pdr/rangerR isinstancestrKeyErrorsplitlenr(getattrdtdatarSdims) variablesrrr_rvariableZ split_keyref_namevar_nameZref_varZ virtual_varr7/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/dataset.py_get_virtual_variables(        r%stuplerNone)argsmsgrcCs|rt||dSN) ValueError)rrrrr _assert_emptysrc sXddlm}t|triS|j}|j}|jditfddt ||D}tt sbdkrnt |tfddt ||D}|j j|||j|d}|jrJt |||D]\}}} z |} Wntk rYqYnXt| t rt| || nt| dd } tt| dd | } | rtd |d t| d qt t ||S) z] Return map from each dim to chunk sizes, accounting for backend's preferred chunks. rNpreferred_chunksc3s|]\}}||VqdSrget).0dimsize)rrr sz_get_chunk..autoc3s"|]\}}|dp|VqdSrr)rrpreferred_chunk_sizeschunksrrrs)shapedtypeZprevious_chunkszFThe specified Dask chunks separate the stored chunks along dimension "z" starting at index zM. This could degrade performance. Instead, consider rechunking after loading.) dask.arrayarrayrrRrrencodingrrziprdictfromkeyscoreZnormalize_chunksrrrr itertools accumulateset differencewarningswarnmin) varrdarrZpreferred_chunk_shapeZ chunk_shaperrZ chunk_sizesrZpreferred_stopsZbreaksr)rrr _get_chunksL       rxarray-Fc sddlm}dk r(fdd|jD|jr|||r:|n|j} ||d| } |j| ||d}|r|jdk rtdd|jD|jd <|S|SdS) Nr)tokenizecsi|]}|kr||qSrrrrrrr sz _maybe_chunk..-)rlock inline_arraycss|]}|dVqdSrNrrxrrrr sz_maybe_chunk..r) dask.baserrndim_datachunkrrr) rrrtokenr name_prefixZoverwrite_encoded_chunksrrZtoken2Zname2rrr _maybe_chunk s rr Dataset)objrcCs(t|dr|}t|ts$t|}|S)zCast the given object to a Dataset. Handles Datasets, DataArrays and dictionaries of variables. A new Dataset object is only created if the provided object is not already one. to_dataset)hasattrrrr)rrrr as_dataset&s   rcCsvzt|j}Wn$tk r4i}|s0tdYnX|r@|}n.t|dd}tdd|Drntd||fS)zkUse `inspect.signature` to try accessing `func` args. Otherwise, ensure they are provided by user. zGUnable to inspect `func` signature, and `param_names` was not provided.rNcSsg|]}|j|j|jfkqSr)kindVAR_POSITIONAL VAR_KEYWORDrprrr Dsz"_get_func_args..zN`param_names` must be provided because `func` takes variable length arguments.)inspect signature parametersrlistanyvalues)func param_names func_argsparamsrrr_get_func_args3s$ rcCsdd}dd|D}dd|D}|D]}||krV||j||jk rV||j||<||krt||||<||||dks||||dkr|||d||d||<||kr(||||<q(||fS)zpSet initial guess and bounds for curvefit. Priority: 1) passed args 2) func signature 3) scipy defaults cSs`t|}t|}td||t||@|dt||@|dt||@g}|S)Ng?r)npisfiniteZnansumint)ZlbZubZ lb_finiteZ ub_finitep0rrr_initialize_feasibleQs  z9_initialize_curvefit_params.._initialize_feasiblecSsi|] }|dqSrrrrrrr^sz/_initialize_curvefit_params..cSsi|]}|tj tjfqSr)rinfrrrrr_srr)defaultemptyr)rrboundsrrparam_defaultsbounds_defaultsrrrr_initialize_curvefit_paramsLs (rc@seZdZdZddddZdddd Zd dd d Zd ddddZd ddddZddddZ e ddddZ e ddddZ ddZ d S)! DataVariables_datasetrdatasetcCs ||_dSrrselfrrrr__init__oszDataVariables.__init__Iterator[Hashable]rcsfddjjDS)Nc3s|]}|jjkr|VqdSrr _coord_namesrrrrrrss z)DataVariables.__iter__..)r _variablesr rr r__iter__rs zDataVariables.__iter__rcCst|jjt|jjSr)rrr rr rrr__len__yszDataVariables.__len__rboolrrcCs||jjko||jjkSr)rr rrrrrr __contains__|szDataVariables.__contains__r_cCs(||jjkrtd|j|St|dS)Nr_)rrrrrrrr __getitem__s zDataVariables.__getitem__rcCs t|Sr)rZdata_vars_reprr rrr__repr__szDataVariables.__repr__zMapping[Hashable, Variable]cs|jjtfdd|DS)Ncsi|]}||qSrrrkZ all_variablesrrrsz+DataVariables.variables..)rrrGr rrrrszDataVariables.variablesFrozen[Hashable, np.dtype]cCs|jjS)zMapping from data variable names to dtypes. Cannot be modified directly, but is updated when adding new variables. See Also -------- Dataset.dtype )rrr rrrrs zDataVariables.dtypescsfddjDS)z6Provide method for the key-autocompletions in IPython.csg|]}|jjkr|qSrrr r rrrs z;DataVariables._ipython_key_completions_..)r_ipython_key_completions_r rr rrs z'DataVariables._ipython_key_completions_N)__name__ __module__ __qualname__ __slots__rr r rrrpropertyrrrrrrrrls rr_c@s<eZdZdZddddZdddddZd d d d Zd S) _LocIndexerrrEcCs ||_dSrrrrrrrsz_LocIndexer.__init__Mapping[Any, Any]rcCst|std|j|S)Nz-can only lookup dictionaries from Dataset.loc)r!rO TypeErrorrselrrrrrs z_LocIndexer.__getitem__rrcCs4t|std|t|j|j}||j|<dS)NzFcan only set locations defined by dictionaries from Dataset.loc. Got: )r!rOr r:r dim_indexers)rrvaluer"rrr __setitem__s  z_LocIndexer.__setitem__N)rrrrrrr$rrrrrsrc@seZdZUdZded<ded<ded<ded <ded <d ed <d ed<ded<dZddddddddZeddddddZe dddd Z e d!dd"d#Z e j d$dd%d&d#Z e d!dd'd(Z e j d$dd%d)d(Z e d*dd+d,Ze d*dd-d.Ze d/dd0d1Zddd2d3d4Zd5d6Zd7d8Zd9d:Zd;d<Ze d=d>Ze d?d@ZdAdBZdCdDZddEddFdGdHZddIddJdKddLdMdNZddd2dOdPZddd2dQdRZddd2dSdTZedddUddVdWdXdWd ddY dZd[Zddde de d\fdd]d^dVd_d`dadbddc dddeZ!de dd\fdddfd_d`dbddgdhdiZ"dde d\fdddfdjd_dbddkdldmZ#dddndodpdpdqddrdsdtZ$dddbduddvdwdxZ%dddbdudyddzd{d|Z&ddd2d}d~Z'dddyddddZ(ddd2ddZ)ddddddZ*dddddZ+e ddddZ,e ddddZ-ddbdddZ.ddddZ/dbdddZ0ddddZ1dddZ2e ddddZ3e ddd2ddZ4e5dddddZ6e5ddddddZ6ddddddZ6ddddddZ7ddZ8dddddZ9dZ:dddbdddZ;ddbdddZe dddd„Z?e ddddńZ@e ddddȄZAe dddd˄ZBdddddd΄ZCddddbddМdd҄ZDdddԜddքZEe5dddddddddbdbdd ddZFe5ddddddddddbdd ddZFe5dd\ddddddddddbdd ddZFdddddddddbdbdd ddZFe5dddddddddddbdddd ddZGe5dddddddddddddddddbddd ddZGdddddddbddddbdddd ddZGddddZHddddZIddddddZJe dddd ZKe ddd d ZLid dd\d\fdd dddbdbdddddZMdd$dddddZNd$ddddZOddZPddddbdddddd ZQdd!dd$dbddd"d#d$ZRddddېd%dbddd&d'd(ZSddd)ddd*d+d,ZTddd)ddd*d-d.ZUddd)ddd*d/d0ZVddd1ddd2d3d4ZWd5d6dd dd7d7dd8d9d:ZXdddeYjZfdd1d;d%dbddd<d=d>Z[ddddeYjZfddd;d%dbdddd?d@dAZ\ddddeYjZd\fdddېd%dbddbdddB dCdDZ]ddddGdbdHddddIdJdKZ^dĐd1dGdbdHdddLdMdNZ_dOddPdQZ`dRddSdTdUZadRdRdVdWdXdYZbdRdRdZdWd[d\Zcddd]ddd^d_d`Zdddd]ddd^dadbZeddd]dddcdddeZfddd]ddd^dfdgZgddd]ddhdidjZhdʐdkdldddmdndoZidːdpdbdqddrdsdtZjdddqdbddudvdwZkdddxdyddzd{d|Zlddd}d~ddddZmdϐddddZnddddddddddZoddepfdddddddddZqdddddddddZrdddddbddddZsddddbddddZtdeYjZd\fddddbddddZuddddddZvewddeYjZdfddd̐ddddddddZxdddbddddZydddd̐dddddZzdddd̐dddddZ{dԐddddddddZ|dՐddddddddZ}dddd2ddZ~dddddddddZdd!ddddddd„ZddddddddŜdƐdDŽZddddȜdɐdʄZddddGddːdddd͜dΐdτZddddddМdѐd҄ZddddddМdӐdԄZdddddՐdքZddd\d\dלdddddbdbdddٜdڐdۄZddddddddޜdߐdZddddddddޜddZddddddddZdddddddZddddddZddddZddddZddddddZdddddddZdddddddZeddddbddddZdddbddddZddbdbddddZedd$dd d d Zddd2d d ZdddddZddd2ddZddbddddZddZdddddddddZdeYjZfddddddd d!Zddddbddd"d#d$Zddd%dbdd&d'd(Zddd)dϐd*dbddd+dd, d-d.Zddddbddd/d0d1Zdddd2d3dd4d5d6Zdddqd7dd8d9d:Zdd;d<Zdddqd7dd8d=d>Ze ddd2d?d@Ze ddd2dAdBZeeZddd2dCdDZddd2dEdFZddGdHdHdIdJdKdLdMZddddddNdOdbdPddQ dRdSZdddUdVdWdXdWdYddddZ d[d\ZddeYjZdfddddddd]d^d_ZddeYjZdfddddddd]d`daZdddddbdcddZdddddbdedfZddddhdiddddjdkdlZdddmdnddbdododpdoddq drdsZddd̐duddvdwdxZdddzdd{d|ddd}d~dZddddddddZdddbdbddddZddd)dbdddbdbdbdd ddZdddddZdddddddddZddddddddddZdddddddddddddd ddZdS(raxA multi-dimensional, in memory, array database. A dataset resembles an in-memory representation of a NetCDF file, and consists of variables, coordinates and attributes which together form a self describing dataset. Dataset implements the mapping interface with keys given by variable names and values given by DataArray objects for each variable name. One dimensional variables with name equal to their dimension are index coordinates used for label based indexing. To load data from a file or file-like object, use the `open_dataset` function. Parameters ---------- data_vars : dict-like, optional A mapping from variable names to :py:class:`~xarray.DataArray` objects, :py:class:`~xarray.Variable` objects or to tuples of the form ``(dims, data[, attrs])`` which can be used as arguments to create a new ``Variable``. Each dimension must have the same length in all variables in which it appears. The following notations are accepted: - mapping {var name: DataArray} - mapping {var name: Variable} - mapping {var name: (dimension name, array-like)} - mapping {var name: (tuple of dimension names, array-like)} - mapping {dimension name: array-like} (it will be automatically moved to coords, see below) Each dimension must have the same length in all variables in which it appears. coords : dict-like, optional Another mapping in similar form as the `data_vars` argument, except the each item is saved on the dataset as a "coordinate". These variables have an associated meaning: they describe constant/fixed/independent quantities, unlike the varying/measured/dependent quantities that belong in `variables`. Coordinates values may be given by 1-dimensional arrays or scalars, in which case `dims` do not need to be supplied: 1D arrays will be assumed to give index values along the dimension with the same name. The following notations are accepted: - mapping {coord name: DataArray} - mapping {coord name: Variable} - mapping {coord name: (dimension name, array-like)} - mapping {coord name: (tuple of dimension names, array-like)} - mapping {dimension name: array-like} (the dimension name is implicitly set to be the same as the coord name) The last notation implies that the coord name is the same as the dimension name. attrs : dict-like, optional Global attributes to save on this dataset. Examples -------- Create data: >>> np.random.seed(0) >>> temperature = 15 + 8 * np.random.randn(2, 2, 3) >>> precipitation = 10 * np.random.rand(2, 2, 3) >>> lon = [[-99.83, -99.32], [-99.79, -99.23]] >>> lat = [[42.25, 42.21], [42.63, 42.59]] >>> time = pd.date_range("2014-09-06", periods=3) >>> reference_time = pd.Timestamp("2014-09-05") Initialize a dataset with multiple dimensions: >>> ds = xr.Dataset( ... data_vars=dict( ... temperature=(["x", "y", "time"], temperature), ... precipitation=(["x", "y", "time"], precipitation), ... ), ... coords=dict( ... lon=(["x", "y"], lon), ... lat=(["x", "y"], lat), ... time=time, ... reference_time=reference_time, ... ), ... attrs=dict(description="Weather related data."), ... ) >>> ds Dimensions: (x: 2, y: 2, time: 3) Coordinates: lon (x, y) float64 -99.83 -99.32 -99.79 -99.23 lat (x, y) float64 42.25 42.21 42.63 42.59 * time (time) datetime64[ns] 2014-09-06 2014-09-07 2014-09-08 reference_time datetime64[ns] 2014-09-05 Dimensions without coordinates: x, y Data variables: temperature (x, y, time) float64 29.11 18.2 22.83 ... 18.28 16.15 26.63 precipitation (x, y, time) float64 5.68 9.256 0.7104 ... 7.992 4.615 7.805 Attributes: description: Weather related data. Find out where the coldest temperature was and what values the other variables had: >>> ds.isel(ds.temperature.argmin(...)) Dimensions: () Coordinates: lon float64 -99.32 lat float64 42.21 time datetime64[ns] 2014-09-08 reference_time datetime64[ns] 2014-09-05 Data variables: temperature float64 7.182 precipitation float64 8.326 Attributes: description: Weather related data. zdict[Hashable, Any] | None_attrszdict[str, Any]_cachez set[Hashable]rzdict[Hashable, int]_dims _encodingzCallable[[], None] | None_closezdict[Hashable, Index]_indexeszdict[Hashable, Variable]r ) r%r&rr'r(r)r*r  __weakref__NzMapping[Any, Any] | Noner) data_varscoordsattrsrc Cs|dkr i}|dkri}t|t|@}|rrr%r)r(r rr'r*) rr,r-r.Zboth_data_and_coordsr coord_namesrindexes_rrrrMs.   zDataset.__init__ztype[T_Dataset]rE)clsrcCs:|\}}|r|||\}}|||d}||j|S)zWCreate a new dataset from the contents of a backends.*DataStore object r.)loadZ set_closeclose)r5storedecoderr attributesrrrr load_storeqs    zDataset.load_storezFrozen[Hashable, Variable]rcCs t|jS)a5Low level interface to Dataset contents as dict of Variable objects. This ordered dictionary is frozen to prevent mutation that could violate Dataset invariants. It contains all variable objects constituting the Dataset, including both data variables and coordinates. )rGr r rrrr}s zDataset.variableszdict[Any, Any]cCs|jdkri|_|jS)z/Dictionary of global attributes on this datasetN)r%r rrrr.s z Dataset.attrsr)r#rcCst||_dSr)rr%rr#rrrr.scCs|jdkri|_|jS)z8Dictionary of global encoding attributes on this datasetN)r(r rrrrs zDataset.encodingcCst||_dSr)rr(r=rrrrszFrozen[Hashable, int]cCs t|jS)atMapping from dimension names to lengths. Cannot be modified directly, but is updated when adding new variables. Note that type of this object differs from `DataArray.dims`. See `Dataset.sizes` and `DataArray.sizes` for consistently named properties. See Also -------- Dataset.sizes DataArray.dims )rGr'r rrrrsz Dataset.dimscCs|jS)a1Mapping from dimension names to lengths. Cannot be modified directly, but is updated when adding new variables. This is an alias for `Dataset.dims` provided for the benefit of consistency with `DataArray.sizes`. See Also -------- DataArray.sizes rr rrrsizess z Dataset.sizesrcstfddjDS)zMapping from data variable names to dtypes. Cannot be modified directly, but is updated when adding new variables. See Also -------- DataArray.dtype cs"i|]\}}|jkr||jqSr)rr)rnvr rrrs z"Dataset.dtypes..)rGr itemsr rr rrs  zDataset.dtypes)rrcKs|dd|jD}|rTddlm}|j||}t||D]\}}||j|_q>|jD]\}}||kr^|q^|S)aManually trigger loading and/or computation of this dataset's data from disk or a remote source into memory and return this dataset. Unlike compute, the original dataset is modified and returned. 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. However, this method can be necessary when working with many file objects on disk. Parameters ---------- **kwargs : dict Additional keyword arguments passed on to ``dask.compute``. See Also -------- dask.compute cSs"i|]\}}t|jr||jqSrrCrrrrArrrrs z Dataset.load..rN) rrBrrcomputerrrr7)rkwargs lazy_datarevaluated_datarrrArrrr7s  z Dataset.loadcCs&ddlm}|t||j|j|jfS)Nr)normalize_token)rrItyper rr%)rrIrrr__dask_tokenize__s zDataset.__dask_tokenize__cCs~dd|jD}dd|D}|s.dSzddlm}|j|WStk rxddlm}|j|YSXdS)NcSsi|]\}}||qSr)__dask_graph__rDrrrrsz*Dataset.__dask_graph__..cSsi|]\}}|dk r||qSrrrDrrrrsrHighLevelGraph) sharedict) rrBdask.highlevelgraphrNmerger ImportErrordaskrO)rZgraphsrNrOrrrrLs  zDataset.__dask_graph__cs ddlfdd|jDS)Nrcsg|]}|r|qSr)is_dask_collection __dask_keys__rrArSrrrs z)Dataset.__dask_keys__..)rSrrr rrWrrU s zDataset.__dask_keys__cs&ddltfdd|jDdS)Nrc3s |]}|r|VqdSr)rT__dask_layers__rVrWrrrs z*Dataset.__dask_layers__..r)rSsumrrr rrWrrXs zDataset.__dask_layers__cCsddlm}|jjSNr)rrArray__dask_optimize__rrrrrr\"s zDataset.__dask_optimize__cCsddlm}|jjSrZ)rrr[__dask_scheduler__r]rrrr^(s zDataset.__dask_scheduler__cCs |jdfSNr)_dask_postcomputer rrr__dask_postcompute__.szDataset.__dask_postcompute__cCs |jdfSr_)_dask_postpersistr rrr__dask_postpersist__1szDataset.__dask_postpersist__zIterable[Variable])rresultsrc Cs~ddl}i}t|}|jD]8\}}||rN|\}}|t|f|}|||<qt|||j |j |j |j |j |jSrZ)rSiterr rBrTranextrJ_construct_directrr'r%r*r(r)) rrdrSrZ results_iterrrArebuildrrrrr`4s"   zDataset._dask_postcomputerenamerzMapping[str, str] | None)rdskrjrc s*ddlm}ddlm}ddlm}i}|jD]\}}||sL|||<q2t||r| } rtfdd| D} | | } nRrddl m } m fdd| |D} ||| \} } n|||\} } |\}}rd ini}|| f||||<q2t|||j|j|j|j|j|jS) Nr)rTrM)cullcsg|]}||qSrrrrirrr_sz-Dataset._dask_postpersist..)flattenreplace_name_in_keycsg|]}|qSrrrrjrnrrrfsrj)rSrTrPrNZdask.optimizationrlr rBrrXZ cull_layersrrmrnrUrcrJrgrr'r%r*r(r))rrkrjrTrNrlrrrAZlayersZdsk2rmkeysr4rhrrFrrorrbJs@        zDataset._dask_postpersistcKs|jdd}|jf|S)aManually trigger loading and/or computation of this dataset's data from disk or a remote source into memory and return a new dataset. Unlike load, the original dataset 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. However, this method can be necessary when working with many file objects on disk. Parameters ---------- **kwargs : dict Additional keyword arguments passed on to ``dask.compute``. See Also -------- dask.compute Fdeep)copyr7rrFnewrrrrE}s zDataset.computecKsTdd|jD}|rPddl}|j||}t||D]\}}||j|_q:|S)z!Persist all Dask arrays in memorycSs"i|]\}}t|jr||jqSrrCrDrrrrs z,Dataset._persist_inplace..rN)rrBrSpersistrrr)rrFrGrSrHrrrrr_persist_inplaceszDataset._persist_inplacecKs|jdd}|jf|S)aZTrigger computation, keeping data as dask arrays This operation can be used to trigger computation on underlying dask arrays, similar to ``.compute()`` or ``.load()``. However this operation keeps the data as dask arrays. This is particularly useful when using the dask.distributed scheduler and you want to load a large amount of data into distributed memory. Parameters ---------- **kwargs : dict Additional keyword arguments passed on to ``dask.persist``. See Also -------- dask.persist Frq)rsrwrtrrrrvs zDataset.persistzdict[Any, Variable]zdict[Any, int] | Nonez dict | Nonezdict[Any, Index] | None) r5rr2rr.r3rr8rc CsT|dkrt|}|dkri}t|}||_||_||_||_||_||_||_ |S)zaShortcut around __init__ for internal use when we want to skip costly validation N) rVobject__new__r rr'r*r%r)r() r5rr2rr.r3rr8rrrrrgs zDataset._construct_directFzdict[Hashable, Variable] | Nonezset[Hashable] | Nonez$dict[Hashable, Any] | None | Defaultzdict[Hashable, Index] | Nonezdict | None | Defaultr) rrr2rr.r3rinplacerc Cs|r^|dk r||_|dk r ||_|dk r.||_|tk r<||_|dk rJ||_|tk rX||_|}n|dkrp|j}|dkr|j}|dkr|j}|tkrt|j}|dkr|j}|tkrt|j}|||||||}|S)a5Fastpath constructor for internal use. Returns an object with optionally with replaced attributes. Explicitly passed arguments are *not* copied when placed on the new dataset. It is up to the caller to ensure that they have the right type and are not used elsewhere. N) r rr'rJr%r*r(rsrg) rrr2rr.r3rrzrrrr_replacesF      zDataset._replacez set | None)rrr2r.r3rzrcCst|}|j||||||dS)z/Replace variables with recalculated dimensions.rzrVr{)rrr2r.r3rzrrrr_replace_with_new_dimss zDataset._replace_with_new_dimszdict[Hashable, int] | None)rrr2rr.rzrcCs&|dkrt|}|j||||d|dS)zDeprecated version of _replace_with_new_dims(). Unlike _replace_with_new_dims(), this method always recalculates indexes from variables. N)r3rzr})rrr2rr.rzrrr_replace_vars_and_dimss zDataset._replace_vars_and_dimszMapping[Hashable, Index]z"Mapping[Hashable, Variable] | Nonezlist[Hashable] | Nonez"Mapping[Hashable, Hashable] | None)rr3rdrop_variables drop_indexes rename_dimsrcCs|s|S|dkri}|dkr g}|dkr,g}|j}|j}t|j}i} i} |D]R\} } |j| } | dk r| j| j| j | j | |kr| | | <qZ| | | <qZ|D]} || || <q| D]\} } | | | || <q| D]}| |q|| |D]} | | q |D]&} | | | | d| | q |j |||d}|r||}|i|\}}|j |||dS|SdS)zsMaybe replace indexes. This function may do a lot more depending on index query results. Nrr2r3)rr2r)r rsrrr*rBrr.updateraddpopremover{ _rename_dims _rename_vars)rr3rrrr new_variablesnew_coord_names new_indexesindex_variablesZno_index_variablesrrZold_varrZreplacedrrrr_overwrite_indexes(sb             zDataset._overwrite_indexeszMapping[Any, ArrayLike] | None)rrrrrcCs|j||dS)a Returns a copy of this dataset. If `deep=True`, a deep copy is made of each of the component variables. Otherwise, a shallow copy of each of the component variable is made, so that the underlying memory region of the new dataset is the same as in the original dataset. Use `data` to create a new object with the same structure as original but entirely new data. Parameters ---------- deep : bool, default: False Whether each component variable is loaded into memory and copied onto the new object. Default is False. data : dict-like or None, optional Data to use in the new object. Each item in `data` must have same shape as corresponding data variable in original. When `data` is used, `deep` is ignored for the data variables and only used for coords. Returns ------- object : Dataset New object with dimensions, attributes, coordinates, name, encoding, and optionally data copied from original. Examples -------- Shallow copy versus deep copy >>> da = xr.DataArray(np.random.randn(2, 3)) >>> ds = xr.Dataset( ... {"foo": da, "bar": ("x", [-1, 2])}, ... coords={"x": ["one", "two"]}, ... ) >>> ds.copy() Dimensions: (dim_0: 2, dim_1: 3, x: 2) Coordinates: * x (x) >> ds_0 = ds.copy(deep=False) >>> ds_0["foo"][0, 0] = 7 >>> ds_0 Dimensions: (dim_0: 2, dim_1: 3, x: 2) Coordinates: * x (x) >> ds Dimensions: (dim_0: 2, dim_1: 3, x: 2) Coordinates: * x (x) >> ds.copy(data={"foo": np.arange(6).reshape(2, 3), "bar": ["a", "b"]}) Dimensions: (dim_0: 2, dim_1: 3, x: 2) Coordinates: * x (x) >> ds Dimensions: (dim_0: 2, dim_1: 3, x: 2) Coordinates: * x (x)   z Dataset._copycCs |jddS)NFrqrr rrr__copy__szDataset.__copy__)rrrcCs|jd|dS)NT)rrrr)rrrrr __deepcopy__szDataset.__deepcopy__cCs dd|jD}|j|dS)z Coerces wrapped data and coordinates into numpy arrays, returning a Dataset. See also -------- DataArray.as_numpy DataArray.to_numpy : Returns only the data as a numpy.ndarray object. cSsi|]\}}||qSr)as_numpyrDrrrrsz$Dataset.as_numpy..r)rrBr{)rZnumpy_variablesrrrrs zDataset.as_numpyzIterable[Hashable])rnamesrc s^i}t}i}|D]}zj|||<Wqtk rtj|j\}}}|||<|jksj|jkrt|||f|jkrt||\} |fdd| D|| || YqXqt } | D]} | | jqЇfdd| D} jD]>} | jkr qtj | j| krj| || <|| q|t j |j||| |dS)zCreate a new Dataset with the listed variables from this dataset and the all relevant coordinates. Skips all validation. csi|] }|qSrrrindexrrr(sz(Dataset._copy_listed..csi|]}|j|qSrr>rr rrr0sr3)rr rrrrrr4rrIrrr5r*r{)rrrr2r3rrrrr needed_dimsrArrr)rrr _copy_listeds@        zDataset._copy_listedrr_)rrc Csddlm}z|j|}Wn*tk rDt|j||j\}}}YnXt|j}i}|jD]0}||jkrZt|j|j|krZ|j|||<qZt |j t|}|||||ddS)z.Construct a DataArray by indexing this datasetrr^T)rr3fastpath) rr_r rrrrrrr5r*) rrr_rr4rr-rr3rrr_construct_dataarray?s   zDataset._construct_dataarrayz Iterable[Mapping[Hashable, Any]]ccs|jEdH|jVdS)z2Places to look-up items for attribute-style accessN) _item_sourcesr.r rrr _attr_sourcesTs zDataset._attr_sourcesccs.|jVt|j|jdVt|j|dVdS)z*Places to look-up items for key-completion)rpmappingN)r,rHrr-rr rrrrZszDataset._item_sourcesrxrcCs ||jkS)zzThe 'in' operator will return true or false depending on whether 'key' is an array in the dataset or not. r rrrrrcszDataset.__contains__rcCs t|jSr)rr,r rrrr iszDataset.__len__cCs t|jSr)rr,r rrr__bool__lszDataset.__bool__rcCs t|jSr)rer,r rrrr oszDataset.__iter__cCs tddS)Nzcannot directly convert an xarray.Dataset into a numpy array. Instead, create an xarray.DataArray first, either with indexing on the Dataset or by invoking the `to_array()` method.)r )rrrrr __array__rszDataset.__array__cCstdd|jDS)z Total bytes consumed by the data arrays of all variables in this dataset. If the backend array for any variable does not include ``nbytes``, estimates the total bytes for that array based on the ``size`` and ``dtype``. css|] }|jVqdSr)nbytesrVrrrrsz!Dataset.nbytes..)rYrrr rrrrzszDataset.nbytesz_LocIndexer[T_Dataset]cCst|S)zAttribute for location based indexing. Only supports __getitem__, and only when the key is a dict of the form {dim: labels}. )rr rrrlocsz Dataset.loccCsdSrrrrrrrszDataset.__getitem__)rrrcCsdSrrrrrrrsz1Mapping[Any, Any] | Hashable | Iterable[Hashable]zT_Dataset | DataArraycCsTt|r|jf|St|r*||St|r>||Stdt|dS)zAccess variables or coordinates of this dataset as a :py:class:`~xarray.DataArray` or a subset of variables or a indexed dataset. Indexing with a list of names will return a new ``Dataset`` object. Unsupported key-type N) r!rOiselhashableriterable_of_hashablerrrJrrrrrs      z'Hashable | Iterable[Hashable] | Mappingr )rr#rc Csddlm}t|r|||}g}|D]f\}}z||||<||Wq.tk r}z$|r~td|d||n|W5d}~XYq.Xq.n t |rt |t rt d| ||int|rt|}t|dkrtdt|dkr| |d|int|t|kr@td t|d t|d t |t rh| tt||jn*t ||r~td n| tt||ntd t|dS)aAdd an array to this dataset. Multiple arrays can be added at the same time, in which case each of the following operations is applied to the respective value. If key is dict-like, update all variables in the dataset one by one with the given value at the given location. If the given value is also a dataset, select corresponding variables in the given value and in the dataset to be changed. If value is a ` from .dataarray import DataArray`, call its `select_vars()` method, rename it to `key` and merge the contents of the resulting dataset into this dataset. If value is a `Variable` object (or tuple of form ``(dims, data[, attrs])``), add it to this dataset as a new variable. rr^z8An error occurred while setting values of the variable 'z;'. The following variables have been successfully updated: NzoCannot assign a Dataset to a single key - only a DataArray or Variable object can be stored under a single key.z!Empty list of variables to be setrz*Different lengths of variables to be set (z&) and data used as input for setting ()z/Cannot assign single DataArray to multiple keysr)rr_r!rO_setitem_checkrBappend Exception RuntimeErrorrrrr rrrrrrrr,rrJ) rrr#r_ processedrreZkeylistrrrr$sL           zDataset.__setitem__c sddlm}ddlm}ttrPfddjD}|rttd|dn$tfdd|t t fDstt d t} D]\}}z ||} Wn:t k r} ztd |d |d | W5d } ~ XYnXttr|nt|rfjD]$} | | jkrtd |d| dqtfdd| jD} | jkrptd |d| djn tj| jdd||<qt|sttr||ddd|S)zConsistency check for __setitem__ When assigning values to a subset of a Dataset, do consistency check beforehand to avoid leaving the dataset in a partially updated state when an error occurs. r)r%r^csg|]}|jkr|qSr)r,rrr rrrs z*Dataset._setitem_check..z Variables z2 in new values not available in original dataset: csg|]}t|qSrr)rt)r#rrrszBDataset assignment only accepts DataArrays, Datasets, and scalars.z Variable 'z ': indexer z not availableNz': dimension 'z<' appears in new values but not in the indexed original datac3s|]}|jkr|VqdSrr>r)valrrrs z)Dataset._setitem_check..z:': dimension order differs between original and new data: z vs. Frsexactjoinrs)xarray.core.alignmentr%rr_rrr,rrrrr rBrrrrrrastyper) rrr#r%r_Z missing_vars new_valuerrZvar_krrrr)rrr#rrsV            zDataset._setitem_checkcCsDt|j|h||jkr |j|=|j|=|j|t|j|_dS)z$Remove a variable from this dataset.N)r3rr*r rdiscardrVr'rrrr __delitem__-s   zDataset.__delitem__r)other compat_strrcs6ddddfdd }|j|jko4tj|j|j|dS)z(Helper function for equals and identicalrSr)ryrcst||Sr)rrrrrrr1@sz#Dataset._all_compat..compatr0)rr! dict_equivr )rrrr1rrr _all_compat;s zDataset._all_compat)rrc Cs.z||dWSttfk r(YdSXdS)aTwo Datasets are broadcast equal if they are equal after broadcasting all variables against each other. For example, variables that are scalar in one dataset but non-scalar in the other dataset can still be broadcast equal if the the non-scalar variable is a constant. See Also -------- Dataset.equals Dataset.identical r/FNrr AttributeErrorrrrrrr/Gs zDataset.broadcast_equalsc Cs.z||dWSttfk r(YdSXdS)aTwo Datasets are equal if they have matching variables and coordinates, all of which are equal. Datasets can still be equal (like pandas objects) if they have NaN values in the same locations. This method is necessary because `v1 == v2` for ``Dataset`` does element-wise comparisons (like numpy.ndarrays). See Also -------- Dataset.broadcast_equals Dataset.identical equalsFNrrrrrrYszDataset.equalsc Cs>zt|j|jo||dWSttfk r8YdSXdS)zLike equals, but also checks all dataset attributes and the attributes on all variables and coordinates. See Also -------- Dataset.broadcast_equals Dataset.equals identicalFN)r!rr.rr rrrrrrms zDataset.identicalzIndexes[pd.Index]cCs |jS)zMapping of pandas.Index objects used for label based indexing. Raises an error if this Dataset has indexes that cannot be coerced to pandas.Index objects. See Also -------- Dataset.xindexes )rZto_pandas_indexesr rrrr3}s zDataset.indexeszIndexes[Index]cstjfddjDS)z>Mapping of xarray Index objects used for label based indexing.csi|]}|j|qSrrrr rrrsz$Dataset.xindexes..)r0r*r rr rrszDataset.xindexesr,cCst|S)z]Dictionary of xarray.DataArray objects corresponding to coordinate variables )r,r rrrr-szDataset.coordsrcCst|S)z?Dictionary of DataArray objects corresponding to data variables)rr rrrr,szDataset.data_varszHashable | Iterable[Hashable]cCsFt|tst|ts|g}nt|}|||}|j||S)axGiven names of one or more variables, set them as coordinates Parameters ---------- names : hashable or iterable of hashable Name(s) of variables in this dataset to convert into coordinates. Returns ------- Dataset See Also -------- Dataset.swap_dims Dataset.assign_coords )rrrr_assert_all_in_datasetrsrr)rrrrrr set_coordss  zDataset.set_coordsrm)rrdroprcCs|dkr|jt|j}nRt|ts.t|ts6|g}nt|}||t|t|j@}|rltd|| }|j ||r|D] }|j |=q|S)aGiven names of coordinates, reset them to become variables Parameters ---------- names : str, Iterable of Hashable or None, optional Name(s) of non-index coordinates in this dataset to reset into variables. By default, all non-index coordinates are reset. drop : bool, default: False If True, remove coordinates instead of converting them into variables. Returns ------- Dataset Nz3cannot remove index coordinates with reset_coords: ) rrr*rrrrrrrsdifference_updater )rrrZ bad_coordsrrrrr reset_coordss"   zDataset.reset_coordsrY)r9rcKsddlm}|||f|dS)z7Store dataset contents to a backends.*DataStore object.r) dump_to_storeN)xarray.backends.apir)rr9rFrrrrrs zDataset.dump_to_storewTzLiteral[('w', 'a')]zT_NetcdfTypes | Nonez str | NonezT_NetcdfEngine | Nonez&Mapping[Any, Mapping[str, Any]] | NonezIterable[Hashable] | Nonebytes) pathmodergroupenginerunlimited_dimsrEinvalid_netcdfrc CsdSrr rrrrrrrrrErrrr to_netcdfs zDataset.to_netcdfzstr | PathLikez Literal[True]c CsdSrrrrrrrs )rzLiteral[False]r{c CsdSrrrrrrr szstr | PathLike | Nonezbytes | Delayed | Nonec Cs6|dkr i}ddlm} | |||||||||d| d S)aIWrite dataset contents to a netCDF file. Parameters ---------- path : str, path-like or file-like, optional Path to which to save this dataset. File-like objects are only supported by the scipy engine. If no path is provided, this function returns the resulting netCDF file as bytes; in this case, we need to use scipy, which does not support netCDF version 4 (the default format becomes NETCDF3_64BIT). mode : {"w", "a"}, default: "w" Write ('w') or append ('a') mode. If mode='w', any existing file at this location will be overwritten. If mode='a', existing variables will be overwritten. format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT", "NETCDF3_CLASSIC"}, optional File format for the resulting netCDF file: * NETCDF4: Data is stored in an HDF5 file, using netCDF4 API features. * NETCDF4_CLASSIC: Data is stored in an HDF5 file, using only netCDF 3 compatible API features. * NETCDF3_64BIT: 64-bit offset version of the netCDF 3 file format, which fully supports 2+ GB files, but is only compatible with clients linked against netCDF version 3.6.0 or later. * NETCDF3_CLASSIC: The classic netCDF 3 file format. It does not handle 2+ GB files very well. All formats are supported by the netCDF4-python library. scipy.io.netcdf only supports the last two formats. The default format is NETCDF4 if you are saving a file to disk and have the netCDF4-python library available. Otherwise, xarray falls back to using scipy to write netCDF files and defaults to the NETCDF3_64BIT format (scipy does not support netCDF4). group : str, optional Path to the netCDF4 group in the given file to open (only works for format='NETCDF4'). The group(s) will be created if necessary. engine : {"netcdf4", "scipy", "h5netcdf"}, optional Engine to use when writing netCDF files. If not provided, the default engine is chosen based on available dependencies, with a preference for 'netcdf4' if writing to a file on disk. encoding : dict, optional Nested dictionary with variable names as keys and dictionaries of variable specific encodings as values, e.g., ``{"my_variable": {"dtype": "int16", "scale_factor": 0.1, "zlib": True}, ...}`` The `h5netcdf` engine supports both the NetCDF4-style compression encoding parameters ``{"zlib": True, "complevel": 9}`` and the h5py ones ``{"compression": "gzip", "compression_opts": 9}``. This allows using any compression plugin installed in the HDF5 library, e.g. LZF. unlimited_dims : iterable of hashable, optional Dimension(s) that should be serialized as unlimited dimensions. By default, no dimensions are treated as unlimited dimensions. Note that unlimited_dims may also be set via ``dataset.encoding["unlimited_dims"]``. compute: bool, default: True If true compute immediately, otherwise return a ``dask.delayed.Delayed`` object that can be computed later. invalid_netcdf: bool, default: False Only valid along with ``engine="h5netcdf"``. If True, allow writing hdf5 files which are invalid netcdf as described in https://github.com/h5netcdf/h5netcdf. Returns ------- * ``bytes`` if path is None * ``dask.delayed.Delayed`` if compute is False * None otherwise See Also -------- DataArray.to_netcdf Nr)rF) rrrrrrrEZ multifiler)rr) rrrrrrrrrErrrrrrs Y z+MutableMapping | str | PathLike[str] | Nonez&MutableMapping | str | PathLike | Nonez%Literal[('w', 'w-', 'a', 'r+', None)]rz bool | NonezHashable | NonezMapping[str, slice] | Nonezdict[str, str] | Nonez int | NonerZ) r9 chunk_storerrrrE consolidated append_dimregion safe_chunksstorage_options zarr_versionrcCsdSrr)rr9rr synchronizerrrrErrrrrrrrrto_zarrszDataset.to_zarr)rrrrr) r9rrrrrErrrrrrc CsdSrr) rr9rrrrrrErrrrrrrrrszZarrStore | DelayedcCs0ddlm}||||| ||||||| | | | dS)aWrite dataset contents to a zarr group. Zarr chunks are determined in the following way: - From the ``chunks`` attribute in each variable's ``encoding`` (can be set via `Dataset.chunk`). - If the variable is a Dask array, from the dask chunks - If neither Dask chunks nor encoding chunks are present, chunks will be determined automatically by Zarr - If both Dask chunks and encoding chunks are present, encoding chunks will be used, provided that there is a many-to-one relationship between encoding chunks and dask chunks (i.e. Dask chunks are bigger than and evenly divide encoding chunks); otherwise raise a ``ValueError``. This restriction ensures that no synchronization / locks are required when writing. To disable this restriction, use ``safe_chunks=False``. Parameters ---------- store : MutableMapping, str or path-like, optional Store or path to directory in local or remote file system. chunk_store : MutableMapping, str or path-like, optional Store or path to directory in local or remote file system only for Zarr array chunks. Requires zarr-python v2.4.0 or later. mode : {"w", "w-", "a", "r+", None}, optional Persistence mode: "w" means create (overwrite if exists); "w-" means create (fail if exists); "a" means override existing variables (create if does not exist); "r+" means modify existing array *values* only (raise an error if any metadata or shapes would change). The default mode is "a" if ``append_dim`` is set. Otherwise, it is "r+" if ``region`` is set and ``w-`` otherwise. synchronizer : object, optional Zarr array synchronizer. group : str, optional Group path. (a.k.a. `path` in zarr terminology.) encoding : dict, optional Nested dictionary with variable names as keys and dictionaries of variable specific encodings as values, e.g., ``{"my_variable": {"dtype": "int16", "scale_factor": 0.1,}, ...}`` compute : bool, optional If True write array data immediately, otherwise return a ``dask.delayed.Delayed`` object that can be computed to write array data later. Metadata is always updated eagerly. consolidated : bool, optional If True, apply zarr's `consolidate_metadata` function to the store after writing metadata and read existing stores with consolidated metadata; if False, do not. The default (`consolidated=None`) means write consolidated metadata and attempt to read consolidated metadata for existing stores (falling back to non-consolidated). When the experimental ``zarr_version=3``, ``consolidated`` must be either be ``None`` or ``False``. append_dim : hashable, optional If set, the dimension along which the data will be appended. All other dimensions on overridden variables must remain the same size. region : dict, optional Optional mapping from dimension names to integer slices along dataset dimensions to indicate the region of existing zarr array(s) in which to write this dataset's data. For example, ``{'x': slice(0, 1000), 'y': slice(10000, 11000)}`` would indicate that values should be written to the region ``0:1000`` along ``x`` and ``10000:11000`` along ``y``. Two restrictions apply to the use of ``region``: - If ``region`` is set, _all_ variables in a dataset must have at least one dimension in common with the region. Other variables should be written in a separate call to ``to_zarr()``. - Dimensions cannot be included in both ``region`` and ``append_dim`` at the same time. To create empty arrays to fill in with ``region``, use a separate call to ``to_zarr()`` with ``compute=False``. See "Appending to existing Zarr stores" in the reference documentation for full details. safe_chunks : bool, optional If True, only allow writes to when there is a many-to-one relationship between Zarr chunks (specified in encoding) and Dask chunks. Set False to override this restriction; however, data may become corrupted if Zarr arrays are written in parallel. This option may be useful in combination with ``compute=False`` to initialize a Zarr from an existing Dataset with arbitrary chunk structure. storage_options : dict, optional Any additional parameters for the storage backend (ignored for local paths). zarr_version : int or None, optional The desired zarr spec version to target (currently 2 or 3). The default of None will attempt to determine the zarr version from ``store`` when possible, otherwise defaulting to 2. Returns ------- * ``dask.delayed.Delayed`` if compute is False * ZarrStore otherwise References ---------- https://zarr.readthedocs.io/ Notes ----- Zarr chunking behavior: If chunks are found in the encoding argument or attribute corresponding to any DataArray, those chunks are used. If a DataArray is a dask array, it is written with those chunks. If not other chunks are found, Zarr uses its own heuristics to choose automatic chunk sizes. encoding: The encoding attribute (if exists) of the DataArray(s) will be used. Override any existing encodings by providing the ``encoding`` kwarg. See Also -------- :ref:`io.zarr` The I/O user guide, with more details and examples. r)r) r9rrrrrrrErrrrr)rr)rr9rrrrrrErrrrrrrrrrrs$ cCs t|Sr)r dataset_reprr rrrrDszDataset.__repr__cCs*tddkr dtt|dSt|S)NZ display_styletextz
z
)r@rreprrrr rrr _repr_html_Gs zDataset._repr_html_z IO | None)bufrc Cs(|dkrtj}g}|d|d|jD] \}}|d|d|dq0|d|jD]l\}}dtt|j}|d|j d |d |d |j D]&\}}|d |d |d|dqqf|d|j D] \}}|d|d|dq|d| d|dS)a Concise summary of a Dataset variables and attributes. Parameters ---------- buf : file-like, default: sys.stdout writable buffer See Also -------- pandas.DataFrame.assign ncdump : netCDF's ncdump Nzxarray.Dataset {z dimensions: z = z ;z variables:,  (z) ;z :z // global attributes:z :} ) sysstdoutrrrBrrmaprrr.write) rrlinesrrrrrrArrrinfoLs$    "  z Dataset.infoz"Mapping[Hashable, tuple[int, ...]]cCst|jS)a Mapping from dimension names to block lengths for this dataset's data, or None if the underlying data is not a dask array. Cannot be modified directly, but can be modified by calling .chunk(). Same as Dataset.chunksizes, but maintained for backwards compatibility. See Also -------- Dataset.chunk Dataset.chunksizes xarray.unify_chunks r)rrr rrrroszDataset.chunkscCst|jS)ao Mapping from dimension names to block lengths for this dataset's data, or None if the underlying data is not a dask array. Cannot be modified directly, but can be modified by calling .chunk(). Same as Dataset.chunks. See Also -------- Dataset.chunk Dataset.chunks xarray.unify_chunks rr rrr chunksizesszDataset.chunksizesrzHint | Literal['auto'] | Mapping[Any, None | int | str | tuple[int, ...]]z"None | int | str | tuple[int, ...])rrrrrr chunks_kwargsrc  sdkr"|dkr"tjdtdittttfrBt|j n t |d |j }|rrt d|fdd|j D}||S)aCoerce all arrays in this dataset into dask arrays with the given chunks. Non-dask arrays in this dataset will be converted to dask arrays. Dask arrays will be rechunked to the given chunk sizes. If neither chunks is not provided for one or more dimensions, chunk sizes along that dimension will not be updated; non-dask arrays will be converted into dask arrays with a single block. Parameters ---------- chunks : int, tuple of int, "auto" or mapping of hashable to int, optional Chunk sizes along each dimension, e.g., ``5``, ``"auto"``, or ``{"x": 5, "y": 5}``. name_prefix : str, default: "xarray-" Prefix for the name of any new dask arrays. token : str, optional Token uniquely identifying this dataset. lock : bool, default: False Passed on to :py:func:`dask.array.from_array`, if the array is not already as dask array. inline_array: bool, default: False Passed on to :py:func:`dask.array.from_array`, if the array is not already as dask array. **chunks_kwargs : {dim: chunks, ...}, optional The keyword arguments form of ``chunks``. One of chunks or chunks_kwargs must be provided Returns ------- chunked : xarray.Dataset See Also -------- Dataset.chunks Dataset.chunksizes xarray.unify_chunks dask.array.from_array Nz]None value for 'chunks' is deprecated. It will raise an error in the future. Use instead '{}')categoryrz4some chunks keys are not dimensions on this object: c s$i|]\}}|t||qSr)rrDrrrrrrrsz!Dataset.chunk..)rr FutureWarningrrrrrrrrMrprrrBr{) rrrrrrrZbad_dimsrrrrrs$3 z Dataset.chunkraiseroz>Iterator[tuple[Hashable, int | slice | np.ndarray | Variable]])indexers missing_dimsrccsHddlm}ddlm}t||j|}|D]\}}t|tt t frT||fVq.t||rl||j fVq.t|t r|t |fVq.t|trtdq.t|trt|dkr|tjdddfVq.t|}|jjdkr|j|}t|tjr|d }nt||rt||j}|jd kr8td |||fVq.d S) zHere we make sure + indexer has a valid keys + indexer is in a valid data type + string indexers are cast to the appropriate date type if the associated index is a DatetimeIndex or CFTimeIndex r)rr^z"cannot use a Dataset as an indexerrint64rZUSzdatetime64[ns]rzAUnlabeled multi-dimensional array cannot be used for indexing: {}N)!xarray.coding.cftimeindexrrr_rLrrBrrslicerSrrrTrr rrrrasarrayrrr*Zto_pandas_indexrZ DatetimeIndexrrZ date_typer IndexErrorr)rrrrr_rrArrrr_validate_indexerss8            zDataset._validate_indexersz#Iterator[tuple[Hashable, Variable]])rrccs||D]\}}t|trB|jdkr6||fVq||fVq t|trj|td||j|jdfVq t|tj r|jdkr|td||j|jdfVq|jdkr|t |f||j|jdfVqt q t t |q dS)z:Variant of _validate_indexers to be used for interpolationrrr6rN)r rrSrto_index_variablerr-r.rndarrayrRAssertionErrorr rJ)rrrrArrr_validate_interp_indexers s        z!Dataset._validate_interp_indexersc sddlm}g}|D]`\}}t||r|jjdkrh|jdkrRtd|j|||j dj }n|j }| |qt |\}}t|fdd|D} fdd|D} | | fS) zExtract coordinates and indexes from indexers. Only coordinate with a name different from any of self.variables will be attached. rr^brzh{:d}d-boolean array is used for indexing along dimension {!r}, but only 1d boolean arrays are supported.cs i|]\}}|jkr||qSrrrDr rrr> s z.cs i|]\}}|jkr||qSrrrDr rrr? s )rr_rBrrrrrrrZnonzeror-rr=r-) rrr_Z coords_listrrAZv_coordsr-r3Zattached_coordsZattached_indexesrr r _get_indexers_coords_and_indexes s,        z(Dataset._get_indexers_coords_and_indexes)rrrrindexers_kwargsrc st||d}tdd|Dr2|j|||dSt||j|}i}i}|j}t|j |\}} |j D]|\} | | kr| | nFfdd| D} | r̈ | |r̈j dkr| |kr|| ql|| <|tjjql|j||||j||j|jdS) aReturns a new dataset with each array indexed along the specified dimension(s). This method selects values from each array using its `__getitem__` method, except this method does not require knowing the order of each array's dimensions. Parameters ---------- indexers : dict, optional A dict with keys matching dimensions and values given by integers, slice objects or arrays. indexer can be a integer, slice, array-like or DataArray. If DataArrays are passed as indexers, xarray-style indexing will be carried out. See :ref:`indexing` for the details. One of indexers or indexers_kwargs must be provided. drop : bool, default: False If ``drop=True``, drop coordinates variables indexed by integers instead of making them scalar. missing_dims : {"raise", "warn", "ignore"}, default: "raise" What to do if dimensions that should be selected from are not present in the Dataset: - "raise": raise an exception - "warn": raise a warning, and ignore the missing dimensions - "ignore": ignore the missing dimensions **indexers_kwargs : {dim: indexer, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. Returns ------- obj : Dataset A new Dataset with the same contents as this dataset, except each array and dimension is indexed by the appropriate indexers. If indexer DataArrays have coordinates that do not conflict with this object, then these coordinates will be attached. In general, each array's data will be a view of the array's data in this dataset, unless vectorized indexing was triggered by using an array indexer, in which case the data will be a copy. See Also -------- Dataset.sel DataArray.isel rcss|]}t|VqdSr)r9)ridxrrrrz szDataset.isel..)rrcs i|]\}}|jkr||qSrr>rDrrrr s z Dataset.isel..r)rr2rr.r3rr8)rMrr _isel_fancyrLrrrsr6rr rBrrrrrrrgr%r(r)) rrrrrrrr2r3rr var_indexersrrrrD s85     z Dataset.iselr)rrrrrcst|||}i}t|j|\}}|jD]\}||krH||} n^fdd|D} | rj| d} ||jkr|r| jdkrq.n j dd} ||kr| } | ||<q.|j | @} | || |} | |\} }|| |||j | @| B} |j || |dS)Ncs i|]\}}|jkr||qSrr>rDrrrr s z'Dataset._isel_fancy..rrFrqr)rr r6rrrBrr-rrsto_base_variablerrpr~rr)rrrrZvalid_indexersrr3rrnew_varrr2selected coord_varsrrrrr s0       zDataset._isel_fancyz*int | float | Iterable[int | float] | None)rrmethod tolerancerrrc Kst||d}t||||d}|rdi}|jD].\}} | jrF| ||<q.||jkr.|j|q.||_|j|j |d} | j | ddS)ad Returns a new dataset with each array indexed by tick labels along the specified dimension(s). In contrast to `Dataset.isel`, indexers for this method should use labels instead of integers. Under the hood, this method is powered by using pandas's powerful Index objects. This makes label based indexing essentially just as fast as using integer indexing. It also means this method uses pandas's (well documented) logic for indexing. This means you can use string shortcuts for datetime indexes (e.g., '2000-01' to select all values in January 2000). It also means that slices are treated as inclusive of both the start and stop values, unlike normal Python indexing. Parameters ---------- indexers : dict, optional A dict with keys matching dimensions and values given by scalars, slices or arrays of tick labels. For dimensions with multi-index, the indexer may also be a dict-like object with keys matching index level names. If DataArrays are passed as indexers, xarray-style indexing will be carried out. See :ref:`indexing` for the details. One of indexers or indexers_kwargs must be provided. method : {None, "nearest", "pad", "ffill", "backfill", "bfill"}, optional Method to use for inexact matches: * None (default): only exact matches * pad / ffill: propagate last valid index value forward * backfill / bfill: propagate next valid index value backward * nearest: use nearest valid index value tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations must satisfy the equation ``abs(index[indexer] - target) <= tolerance``. drop : bool, optional If ``drop=True``, drop coordinates variables in `indexers` instead of making them scalar. **indexers_kwargs : {dim: indexer, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. Returns ------- obj : Dataset A new Dataset with the same contents as this dataset, except each variable and dimension is indexed by the appropriate indexers. If indexer DataArrays have coordinates that do not conflict with this object, then these coordinates will be attached. In general, each array's data will be a view of the array's data in this dataset, unless vectorized indexing was triggered by using an array indexer, in which case the data will be a copy. See Also -------- Dataset.isel DataArray.sel r!)rrr)rrrN) rMr:rrBrrZ drop_coordsrrr"ras_tuple) rrrrrrZ query_resultsZno_scalar_variablesrrAresultrrrr! s"D   z Dataset.selzMapping[Any, int] | int | None)rrrrc s|s*dkrdtts*ts*tdttrHfdd|jDt|dD]H\}}t|tstd|dt|q\|d kr\td |d|q\d dD}| |S) aReturns a new dataset with the first `n` values of each array for the specified dimension(s). Parameters ---------- indexers : dict or int, default: 5 A dict with keys matching dimensions and integer values `n` or a single integer `n` applied over all dimensions. One of indexers or indexers_kwargs must be provided. **indexers_kwargs : {dim: n, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. See Also -------- Dataset.tail Dataset.thin DataArray.head N5indexers must be either dict-like or a single integercsi|] }|qSrrrrrrr< sz Dataset.head..head,expected integer type indexer for dimension , found r3expected positive integer as indexer for dimension cSsi|]\}}|t|qSrrrrrrrrrI s rrrOr rrMrBrJrrrrrrrAZindexers_slicesrrrr" s&   z Dataset.headc s|s*dkrdtts*ts*tdttrHfdd|jDt|dD]H\}}t|tstd|dt|q\|d kr\td |d|q\d dD}| |S) aReturns a new dataset with the last `n` values of each array for the specified dimension(s). Parameters ---------- indexers : dict or int, default: 5 A dict with keys matching dimensions and integer values `n` or a single integer `n` applied over all dimensions. One of indexers or indexers_kwargs must be provided. **indexers_kwargs : {dim: n, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. See Also -------- Dataset.head Dataset.thin DataArray.tail Nr r!csi|] }|qSrrrrrrrj sz Dataset.tail..tailr#r$rr%cSs.i|]&\}}||dkr"t| dnt|qSrr&r'rrrrw sr(r)rrrr*L s*   z Dataset.tailc s|sttststdttr<fdd|jDt|dD]Z\}}t|ts|td|dt|qP|dkrtd|d|qP|dkrPtd qPd dD}| |S) aJReturns a new dataset with each array indexed along every `n`-th value for the specified dimension(s) Parameters ---------- indexers : dict or int A dict with keys matching dimensions and integer values `n` or a single integer `n` applied over all dimensions. One of indexers or indexers_kwargs must be provided. **indexers_kwargs : {dim: n, ...}, optional The keyword arguments form of ``indexers``. One of indexers or indexers_kwargs must be provided. Examples -------- >>> x_arr = np.arange(0, 26) >>> x_arr array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]) >>> x = xr.DataArray( ... np.reshape(x_arr, (2, 13)), ... dims=("x", "y"), ... coords={"x": [0, 1], "y": np.arange(0, 13)}, ... ) >>> x_ds = xr.Dataset({"foo": x}) >>> x_ds Dimensions: (x: 2, y: 13) Coordinates: * x (x) int64 0 1 * y (y) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 Data variables: foo (x, y) int64 0 1 2 3 4 5 6 7 8 9 ... 16 17 18 19 20 21 22 23 24 25 >>> x_ds.thin(3) Dimensions: (x: 1, y: 5) Coordinates: * x (x) int64 0 * y (y) int64 0 3 6 9 12 Data variables: foo (x, y) int64 0 3 6 9 12 >>> x.thin({"x": 2, "y": 5}) array([[ 0, 5, 10]]) Coordinates: * x (x) int64 0 * y (y) int64 0 5 10 See Also -------- Dataset.head Dataset.tail DataArray.thin r!csi|] }|qSrrrrrrr sz Dataset.thin..thinr#r$rr%zstep cannot be zerocSsi|]\}}|tdd|qSrr&r'rrrr sr(r)rrrr+} s.=    z Dataset.thinzDataset | DataArray)rrexcludercCsP|dkrt}nt|}t||dd|d}t||\}}ttd|d|||S)anBroadcast this DataArray against another Dataset or DataArray. This is equivalent to xr.broadcast(other, self)[1] Parameters ---------- other : Dataset or DataArray Object against which to broadcast this array. exclude : iterable of hashable, optional Dimensions that must not be broadcasted NouterF)rrsr,rEr)rr%r$r#r)rrr,rZdims_mapZ common_coordsrrrbroadcast_like s zDataset.broadcast_likezalignment.Alignerzdict[Hashable, Any]zfrozenset[Hashable])alignerdim_pos_indexersrr3 fill_value exclude_dims exclude_varsrcs}|} |D],\} } |j| } | dk r| j| _| j| _q|jD]0\} } |j| } t| j|krP| | | <| || <qP|st| t|jr| | |}n|j|jd}nZfdd|j D}t j |||j||j d}|||jt| B}|j||| d}|S)zCCallback called from ``Aligner`` to create a new reindexed Dataset.Nrqcs&i|]\}}|kr|kr||qSrrrDr3rrrr s z-Dataset._reindex_callback..rsr1sparser)rsrBr rr.rr*rrrrrZreindex_variablesr6rrr~)rr/r0rr3r1r2r3rrrrrr reindexedZ to_reindexZreindexed_varsrrr4r_reindex_callback sD       zDataset._reindex_callbackrv)rrrrrsr1rcCstj||||||dS)un Conform this object onto the indexes of another object, filling in missing values with ``fill_value``. The default fill value is NaN. Parameters ---------- other : Dataset or DataArray Object with an 'indexes' attribute giving a mapping from dimension names to pandas.Index objects, which provides coordinates upon which to index the variables in this dataset. The indexes on this other object need not be the same as the indexes on this dataset. Any mis-matched index values will be filled in with NaN, and any mis-matched dimension names will simply be ignored. method : {None, "nearest", "pad", "ffill", "backfill", "bfill", None}, optional Method to use for filling index values from other not found in this dataset: - None (default): don't fill gaps - "pad" / "ffill": propagate last valid index value forward - "backfill" / "bfill": propagate next valid index value backward - "nearest": use nearest valid index value tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations must satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like must be the same size as the index and its dtype must exactly match the index’s type. copy : bool, default: True If ``copy=True``, data in the return value 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, a new xarray object is always returned. fill_value : scalar or dict-like, optional Value to use for newly missing values. If a dict-like maps variable names to fill values. Returns ------- reindexed : Dataset Another dataset, with this dataset's data but coordinates from the other object. See Also -------- Dataset.reindex align )rrrrsr1)r reindex_like)rrrrrsr1rrrr9) s9zDataset.reindex_like)rrrrrsr1rrcKs$t||d}tj||||||dS)ud"Conform this object onto a new set of indexes, filling in missing values with ``fill_value``. The default fill value is NaN. Parameters ---------- indexers : dict, optional Dictionary with keys given by dimension names and values given by arrays of coordinates tick labels. Any mis-matched coordinate values will be filled in with NaN, and any mis-matched dimension names will simply be ignored. One of indexers or indexers_kwargs must be provided. method : {None, "nearest", "pad", "ffill", "backfill", "bfill", None}, optional Method to use for filling index values in ``indexers`` not found in this dataset: - None (default): don't fill gaps - "pad" / "ffill": propagate last valid index value forward - "backfill" / "bfill": propagate next valid index value backward - "nearest": use nearest valid index value tolerance : optional Maximum distance between original and new labels for inexact matches. The values of the index at the matching locations must satisfy the equation ``abs(index[indexer] - target) <= tolerance``. Tolerance may be a scalar value, which applies the same tolerance to all values, or list-like, which applies variable tolerance per element. List-like must be the same size as the index and its dtype must exactly match the index’s type. copy : bool, default: True If ``copy=True``, data in the return value 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, a new xarray object is always returned. fill_value : scalar or dict-like, optional Value to use for newly missing values. If a dict-like, maps variable names (including coordinates) to fill values. sparse : bool, default: False use sparse-array. **indexers_kwargs : {dim: indexer, ...}, optional Keyword arguments in the same form as ``indexers``. One of indexers or indexers_kwargs must be provided. Returns ------- reindexed : Dataset Another dataset, with this dataset's data but replaced coordinates. See Also -------- Dataset.reindex_like align pandas.Index.get_indexer Examples -------- Create a dataset with some fictional data. >>> x = xr.Dataset( ... { ... "temperature": ("station", 20 * np.random.rand(4)), ... "pressure": ("station", 500 * np.random.rand(4)), ... }, ... coords={"station": ["boston", "nyc", "seattle", "denver"]}, ... ) >>> x Dimensions: (station: 4) Coordinates: * station (station) >> x.indexes Indexes: station Index(['boston', 'nyc', 'seattle', 'denver'], dtype='object', name='station') Create a new index and reindex the dataset. By default values in the new index that do not have corresponding records in the dataset are assigned `NaN`. >>> new_index = ["boston", "austin", "seattle", "lincoln"] >>> x.reindex({"station": new_index}) Dimensions: (station: 4) Coordinates: * station (station) >> x.reindex({"station": new_index}, fill_value=0) Dimensions: (station: 4) Coordinates: * station (station) >> x.reindex( ... {"station": new_index}, fill_value={"temperature": 0, "pressure": 100} ... ) Dimensions: (station: 4) Coordinates: * station (station) >> x.reindex({"station": new_index}, method="nearest") Traceback (most recent call last): ... raise ValueError('index must be monotonic increasing or decreasing') ValueError: index must be monotonic increasing or decreasing To further illustrate the filling functionality in reindex, we will create a dataset with a monotonically increasing index (for example, a sequence of dates). >>> x2 = xr.Dataset( ... { ... "temperature": ( ... "time", ... [15.57, 12.77, np.nan, 0.3081, 16.59, 15.12], ... ), ... "pressure": ("time", 500 * np.random.rand(6)), ... }, ... coords={"time": pd.date_range("01/01/2019", periods=6, freq="D")}, ... ) >>> x2 Dimensions: (time: 6) Coordinates: * time (time) datetime64[ns] 2019-01-01 2019-01-02 ... 2019-01-06 Data variables: temperature (time) float64 15.57 12.77 nan 0.3081 16.59 15.12 pressure (time) float64 481.8 191.7 395.9 264.4 284.0 462.8 Suppose we decide to expand the dataset to cover a wider date range. >>> time_index2 = pd.date_range("12/29/2018", periods=10, freq="D") >>> x2.reindex({"time": time_index2}) Dimensions: (time: 10) Coordinates: * time (time) datetime64[ns] 2018-12-29 2018-12-30 ... 2019-01-07 Data variables: temperature (time) float64 nan nan nan 15.57 ... 0.3081 16.59 15.12 nan pressure (time) float64 nan nan nan 481.8 ... 264.4 284.0 462.8 nan The index entries that did not have a value in the original data frame (for example, `2018-12-29`) are by default filled with NaN. If desired, we can fill in the missing values using one of several options. For example, to back-propagate the last valid value to fill the `NaN` values, pass `bfill` as an argument to the `method` keyword. >>> x3 = x2.reindex({"time": time_index2}, method="bfill") >>> x3 Dimensions: (time: 10) Coordinates: * time (time) datetime64[ns] 2018-12-29 2018-12-30 ... 2019-01-07 Data variables: temperature (time) float64 15.57 15.57 15.57 15.57 ... 16.59 15.12 nan pressure (time) float64 481.8 481.8 481.8 481.8 ... 284.0 462.8 nan Please note that the `NaN` value present in the original dataset (at index value `2019-01-03`) will not be filled by any of the value propagation schemes. >>> x2.where(x2.temperature.isnull(), drop=True) Dimensions: (time: 1) Coordinates: * time (time) datetime64[ns] 2019-01-03 Data variables: temperature (time) float64 nan pressure (time) float64 395.9 >>> x3.where(x3.temperature.isnull(), drop=True) Dimensions: (time: 2) Coordinates: * time (time) datetime64[ns] 2019-01-03 2019-01-07 Data variables: temperature (time) float64 nan nan pressure (time) float64 395.9 nan This is because filling while reindexing does not look at dataset values, but only compares the original and desired indexes. If you do want to fill in the `NaN` values present in the original dataset, use the :py:meth:`~Dataset.fillna()` method. reindex)rrrrsr1r!rMrr:)rrrrrsr1rrrrr:k sOzDataset.reindex) rrrrrsr1r6rrc Ks&t||d}tj|||||||dS)z= Same as reindex but supports sparse option. r:)rrrrsr1r6r;)rrrrrsr1r6rrrr_reindexC s zDataset._reindexlinearnearestrpzMapping[str, Any] | None)rr-r assume_sortedrFmethod_non_numeric coords_kwargsrc s ddlm}|dkri}t||d}t||rvtjjddD | } fdd|D|r~n d d|Dd d d d fdd D} |dkr| D](\} } || | i\} | | | | <q̈rdd| D} i}d}j D]\}|kr:q$tjrL| }n| }jj}|dkrfdd| D}|j||f|||<nB|dkr| j@rd}n"tfddjDr$||<q$|rdd| D}tj||| d}t|j}| |jnfddj D}j| @}j|||d} D]b\} } t| tsvt | j| fkrt!| | | jd}|"| | i}||| <| |n| || <q^|#|\}}| || |j| @| B}j|||dS)aoInterpolate a Dataset onto new coordinates Performs univariate or multivariate interpolation of a Dataset onto new coordinates using scipy's interpolation routines. If interpolating along an existing dimension, :py:class:`scipy.interpolate.interp1d` is called. When interpolating along multiple existing dimensions, an attempt is made to decompose the interpolation into multiple 1-dimensional interpolations. If this is possible, :py:class:`scipy.interpolate.interp1d` is called. Otherwise, :py:func:`scipy.interpolate.interpn` is called. Parameters ---------- coords : dict, optional Mapping from dimension names to the new coordinates. New coordinate can be a scalar, array-like or DataArray. If DataArrays are passed as new coordinates, their dimensions are used for the broadcasting. Missing values are skipped. method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", "barycentric", "krog", "pchip", "spline", "akima"}, default: "linear" String indicating which method to use for interpolation: - 'linear': linear interpolation. Additional keyword arguments are passed to :py:func:`numpy.interp` - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial': are passed to :py:func:`scipy.interpolate.interp1d`. If ``method='polynomial'``, the ``order`` keyword argument must also be provided. - 'barycentric', 'krog', 'pchip', 'spline', 'akima': use their respective :py:class:`scipy.interpolate` classes. assume_sorted : bool, default: False If False, values of coordinates that are interpolated over can be in any order and they are sorted first. If True, interpolated coordinates are assumed to be an array of monotonically increasing values. kwargs : dict, optional Additional keyword arguments passed to scipy's interpolator. Valid options and their behavior depend whether ``interp1d`` or ``interpn`` is used. method_non_numeric : {"nearest", "pad", "ffill", "backfill", "bfill"}, optional Method for non-numeric types. Passed on to :py:meth:`Dataset.reindex`. ``"nearest"`` is used by default. **coords_kwargs : {dim: coordinate, ...}, optional The keyword arguments form of ``coords``. One of coords or coords_kwargs must be provided. Returns ------- interpolated : Dataset New dataset on the new coordinates. Notes ----- scipy is required. See Also -------- scipy.interpolate.interp1d scipy.interpolate.interpn Examples -------- >>> ds = xr.Dataset( ... data_vars={ ... "a": ("x", [5, 7, 4]), ... "b": ( ... ("x", "y"), ... [[1, 4, 2, 9], [2, 7, 6, np.nan], [6, np.nan, 5, 8]], ... ), ... }, ... coords={"x": [0, 1, 2], "y": [10, 12, 14, 16]}, ... ) >>> ds Dimensions: (x: 3, y: 4) Coordinates: * x (x) int64 0 1 2 * y (y) int64 10 12 14 16 Data variables: a (x) int64 5 7 4 b (x, y) float64 1.0 4.0 2.0 9.0 2.0 7.0 6.0 nan 6.0 nan 5.0 8.0 1D interpolation with the default method (linear): >>> ds.interp(x=[0, 0.75, 1.25, 1.75]) Dimensions: (x: 4, y: 4) Coordinates: * y (y) int64 10 12 14 16 * x (x) float64 0.0 0.75 1.25 1.75 Data variables: a (x) float64 5.0 6.5 6.25 4.75 b (x, y) float64 1.0 4.0 2.0 nan 1.75 6.25 ... nan 5.0 nan 5.25 nan 1D interpolation with a different method: >>> ds.interp(x=[0, 0.75, 1.25, 1.75], method="nearest") Dimensions: (x: 4, y: 4) Coordinates: * y (y) int64 10 12 14 16 * x (x) float64 0.0 0.75 1.25 1.75 Data variables: a (x) float64 5.0 7.0 7.0 4.0 b (x, y) float64 1.0 4.0 2.0 9.0 2.0 7.0 ... 6.0 nan 6.0 nan 5.0 8.0 1D extrapolation: >>> ds.interp( ... x=[1, 1.5, 2.5, 3.5], ... method="linear", ... kwargs={"fill_value": "extrapolate"}, ... ) Dimensions: (x: 4, y: 4) Coordinates: * y (y) int64 10 12 14 16 * x (x) float64 1.0 1.5 2.5 3.5 Data variables: a (x) float64 7.0 5.5 2.5 -0.5 b (x, y) float64 2.0 7.0 6.0 nan 4.0 nan ... 4.5 nan 12.0 nan 3.5 nan 2D interpolation: >>> ds.interp(x=[0, 0.75, 1.25, 1.75], y=[11, 13, 15], method="linear") Dimensions: (x: 4, y: 3) Coordinates: * x (x) float64 0.0 0.75 1.25 1.75 * y (y) int64 11 13 15 Data variables: a (x) float64 5.0 6.5 6.25 4.75 b (x, y) float64 2.5 3.0 nan 4.0 5.625 nan nan nan nan nan nan nan r)missingNinterpcSsg|]}t|jqSrrr)rZnxrrrr sz"Dataset.interp..csi|]}|j|qSrrrdr rrr sz"Dataset.interp..cSsg|]}|qSrrrrrrr scSs<z |j|WStk r6t|t|j|fYSXdSr)r rrTrr)rrrrrmaybe_variable s z&Dataset.interp..maybe_variablecSs&t|rt|std|||fS)NzWhen interpolating over a datetime-like coordinate, the coordinates to interpolate to must be either datetime strings or datetimes. Instead got {})r(r r)rZnew_xrrr_validate_interp_indexer sz0Dataset.interp.._validate_interp_indexercs"i|]\}}|||qSrrrD)rHrGrrrr s)r=r>cSs.i|]&\}\}}|||fqSr)rr)rrrdestrrrr& s FZuifccs i|]\}}|jkr||qSrr>rDrrrr9 s ZObUTc3s|]}|kVqdSrrrErrrrC sz!Dataset.interp..cSs&i|]\}\}}|j|fkr||qSrr>)rrr4rArrrrJ s )rrr3csi|]\}}|kr||qSrrrDrrrrW sr)Z coord_dtype)$ xarray.corerBrMrrrr intersectionrrrprsortbyrBZ _localizerLr rCrrrrCallrr:r*rrr~rsrrSr r1create_variablesr)rr-rr?rFr@rArBZsdimsZvalidated_indexersrrAZnewidxZ dask_indexersrr:rZ use_indexersZ dtype_kindrZreindex_indexersr7r3r2rrrrrr)rHrrGrrrrrC[ s             zDataset.interp)rrr?rFr@rcCs|dkr i}i}|j}|jD]*}|j|dd} t| dkr| |||<qi} i} |D]&\} } | jjdkrv| | | <qX| | | <qX|}| r|| }|j| ||||dS)a Interpolate this object onto the coordinates of another object, filling the out of range values with NaN. If interpolating along a single existing dimension, :py:class:`scipy.interpolate.interp1d` is called. When interpolating along multiple existing dimensions, an attempt is made to decompose the interpolation into multiple 1-dimensional interpolations. If this is possible, :py:class:`scipy.interpolate.interp1d` is called. Otherwise, :py:func:`scipy.interpolate.interpn` is called. Parameters ---------- other : Dataset or DataArray Object with an 'indexes' attribute giving a mapping from dimension names to an 1d array-like, which provides coordinates upon which to index the variables in this dataset. Missing values are skipped. method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", "barycentric", "krog", "pchip", "spline", "akima"}, default: "linear" String indicating which method to use for interpolation: - 'linear': linear interpolation. Additional keyword arguments are passed to :py:func:`numpy.interp` - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial': are passed to :py:func:`scipy.interpolate.interp1d`. If ``method='polynomial'``, the ``order`` keyword argument must also be provided. - 'barycentric', 'krog', 'pchip', 'spline', 'akima': use their respective :py:class:`scipy.interpolate` classes. assume_sorted : bool, default: False If False, values of coordinates that are interpolated over can be in any order and they are sorted first. If True, interpolated coordinates are assumed to be an array of monotonically increasing values. kwargs : dict, optional Additional keyword passed to scipy's interpolator. method_non_numeric : {"nearest", "pad", "ffill", "backfill", "bfill"}, optional Method for non-numeric types. Passed on to :py:meth:`Dataset.reindex`. ``"nearest"`` is used by default. Returns ------- interpolated : Dataset Another dataset by interpolating this dataset's data along the coordinates of the other object. Notes ----- scipy is required. If the dataset has object-type coordinates, reindex is used for these coordinates instead of the interpolation. See Also -------- Dataset.interp Dataset.reindex_like NignoreerrorsrZuifcMm)r-rr?rFr@) rrget_all_coordsrrBrrr:rC)rrrr?rFr@r-Z other_indexesrZother_dim_coordsZnumeric_coordsZ object_coordsrrAdsrrr interp_liker s0A      zDataset.interp_likez.tuple[dict[Hashable, Variable], set[Hashable]]c si}t}|jD]n\}}|jdd}tfdd|jD|_|||}||krftd|d|||<||jkr| |q||fS)NFrqc3s|]}||VqdSrrr dims_dictrrr sz'Dataset._rename_vars..z the new name z conflicts) rrrBrsrrrrrr) r name_dictrVrr2rrArrrrUrr s    zDataset._rename_varszMapping[Any, Hashable])rWrcsfdd|jDS)Ncsi|]\}}|||qSrrrDrWrrr s z(Dataset._rename_dims..)rrB)rrWrrXrr szDataset._rename_dimsz6tuple[dict[Hashable, Index], dict[Hashable, Variable]])rWrVrc sjsiifSi}i}jD]f\}}||fdd|D}|fdd|Dfddt||D}||q ||fS)Ncsg|]}||qSrrrrXrrr sz+Dataset._rename_indexes..csi|] }|qSrrr) new_indexrrr sz+Dataset._rename_indexes..csi|]\}}|j|qSrr)roldrur rrr s)r*rZgroup_by_indexrjrrNr) rrWrVr3rrr2rZnew_index_varsr)rWrYrr_rename_indexes s   zDataset._rename_indexeszZtuple[dict[Hashable, Variable], set[Hashable], dict[Hashable, int], dict[Hashable, Index]]csL|||\}}||}|||\}fdd|D}||||fS)Ncsi|]\}}|||qSrrrDrrrr sz'Dataset._rename_all..)rrr[rB)rrWrVrr2rr3rr\r _rename_all s  zDataset._rename_allzMapping[Any, Hashable] | None)rrWrrc Kst||d}|D]}||kr:||jkr:td|dd}||}||jkrz||jkrz|j||j}||fkrd}n.||jkr||jkr|j|j}||fkrd}|rtjd|d||dtd d q|j ||d \}}} } |j ||| | d S) zsAlso used internally by DataArray so that the warning (if any) is raised at the right stack level. rjcannot rename z: because it is not a variable or dimension in this datasetFTzrename  to z} does not create an index anymore. Try using swap_dims instead or use set_index after rename to create an indexed coordinate. stacklevelrWrVrr3) rMrprrrr rr UserWarningr]r{) rrWrrZcreate_dim_coordZnew_kZ coord_dimsrr2rr3rrr_renames6      zDataset._renamecKs|jfd|i|S)aReturns a new object with renamed variables, coordinates and dimensions. Parameters ---------- name_dict : dict-like, optional Dictionary whose keys are current variable, coordinate or dimension names and whose values are the desired names. **names : optional Keyword form of ``name_dict``. One of name_dict or names must be provided. Returns ------- renamed : Dataset Dataset with renamed variables, coordinates and dimensions. See Also -------- Dataset.swap_dims Dataset.rename_vars Dataset.rename_dims DataArray.rename rW)rf)rrWrrrrrj8szDataset.rename)rrVrrc Kst||d}|D]P\}}||jkr6td|d||jksH||krtd|d|d|dq|ji|d\}}}}|j||||d S) aReturns a new object with renamed dimensions only. Parameters ---------- dims_dict : dict-like, optional Dictionary whose keys are current dimension names and whose values are the desired names. The desired names must not be the name of an existing dimension or Variable in the Dataset. **dims : optional Keyword form of ``dims_dict``. One of dims_dict or dims must be provided. Returns ------- renamed : Dataset Dataset with renamed dimensions. See Also -------- Dataset.swap_dims Dataset.rename Dataset.rename_vars DataArray.rename rr^z. because it is not a dimension in this datasetzCannot rename r_z because z- already exists. Try using swap_dims instead.rcrd)rMrBrrr]r{) rrVrrrArr2r?r3rrrrVs   zDataset.rename_dimscKsVt||d}|D]}||krtd|dq|j|id\}}}}|j||||dS)aReturns a new object with renamed variables including coordinates Parameters ---------- name_dict : dict-like, optional Dictionary whose keys are current variable or coordinate names and whose values are the desired names. **names : optional Keyword form of ``name_dict``. One of name_dict or names must be provided. Returns ------- renamed : Dataset Dataset with renamed variables including coordinates See Also -------- Dataset.swap_dims Dataset.rename Dataset.rename_dims DataArray.rename rename_varsr^z; because it is not a variable or coordinate in this datasetrcrd)rMrr]r{)rrWrrrr2rr3rrrrgs  zDataset.rename_vars)rrVrc  srt|dD]R\}}|jkr6td|d|jkrj|j|fkrtd|d|qfddjD}j}|fddDi}i}jD]\}}t fd d |jD} ||krJ| } | | _|j krj |||<| ||<n8t | \} |fd d | D|| || q| } | | _| ||<qj|||d S)aReturns a new object with swapped dimensions. Parameters ---------- dims_dict : dict-like Dictionary whose keys are current dimension names and whose values are new names. **dims_kwargs : {existing_dim: new_dim, ...}, optional The keyword arguments form of ``dims_dict``. One of dims_dict or dims_kwargs must be provided. Returns ------- swapped : Dataset Dataset with swapped dimensions. Examples -------- >>> ds = xr.Dataset( ... data_vars={"a": ("x", [5, 7]), "b": ("x", [0.1, 2.4])}, ... coords={"x": ["a", "b"], "y": ("x", [0, 1])}, ... ) >>> ds Dimensions: (x: 2) Coordinates: * x (x) >> ds.swap_dims({"x": "y"}) Dimensions: (y: 2) Coordinates: x (y) >> ds.swap_dims({"x": "z"}) Dimensions: (z: 2) Coordinates: x (z) sz$Dataset.swap_dims..csh|]}|jkr|qSrrrr rrris c3s|]}||VqdSrrrrUrrrsz$Dataset.swap_dims..csi|] }|qSrrrrrrr sz%Dataset.swap_dims..r)rMrBrrrrrsrrrr r*r4rr~) rrVZ dims_kwargsrrAZ result_dimsr2rr3rrrr)rVrrrrhs>@           zDataset.swap_dimsz8None | Hashable | Sequence[Hashable] | Mapping[Any, Any]zNone | int | Sequence[int])raxis dim_kwargsrc s |dkr nzt|trt|}nft|tr2tdnRt|tsFt|tsP|di}n4t|trt|tt|krvt ddd|D}t ||d}t|t st |dkrt tt|}nt|ts|g}t|t|krt d|D]J}||jkrt d |d ||jkrt|j|st d j|d qi}t|j}|j}|D]n\}} t| d rt| |} | ||<|| ||||j||<nt| trntdj|dqP|jD],\}} ||kr||kr| ||<nt| jt||D]:} | ks&d| krtd| d|dqfdd|D} t| tt| krtt dtt | |} t t | j| j!}| D]\}}|"||q| #t|||<n.||krt$| #|\} }| ||<||q|j%|||dS)aReturn a new object with an additional axis (or axes) inserted at the corresponding position in the array shape. The new object is a view into the underlying array, not a copy. If dim is already a scalar coordinate, it will be promoted to a 1D coordinate consisting of a single value. Parameters ---------- dim : hashable, sequence of hashable, mapping, or None Dimensions to include on the new variable. If provided as hashable or sequence of hashable, then dimensions are inserted with length 1. If provided as a mapping, then the keys are the new dimensions and the values are either integers (giving the length of the new dimensions) or array-like (giving the coordinates of the new dimensions). axis : int, sequence of int, or None, default: None Axis position(s) where new axis is to be inserted (position(s) on the result array). If a sequence of integers is passed, multiple axes are inserted. In this case, dim arguments should be same length list. If axis=None is passed, all the axes will be inserted to the start of the result array. **dim_kwargs : int or sequence or ndarray The keywords are arbitrary dimensions being inserted and the values are either the lengths of the new dims (if int is given), or their coordinates. Note, this is an alternative to passing a dict to the dim kwarg and will only be used if dim is None. Returns ------- expanded : Dataset This object, but with additional dimension(s). See Also -------- DataArray.expand_dims Nz:dim should be hashable or sequence of hashables or mappingrz)dims should not contain duplicate values.cSsi|] }|dqSrrrErrrrRsz'Dataset.expand_dims.. expand_dimsz,lengths of dim and axis should be identical.z Dimension z already exists.z4{dim} already exists as coordinate or variable name.rr z.z(axis should not contain duplicate valuesr2r3)&rrrrr rrrrrrMrr rrrr r!rPrr*rrsrBrr1rrNrrr sortedrrinsertset_dimsr4r~)rrrjrkrFrr3r2rrArrnZaxis_posZ zip_axis_dimZall_dimscrrrorrls+                   zDataset.expand_dimsz2Mapping[Any, Hashable | Sequence[Hashable]] | NonezHashable | Sequence[Hashable])r3rindexes_kwargsrc st||d}i}i}ttit}|D]\}} t| tsPt| tsX| g} nt| } t| tj} | rtd dd| Dd| |  | j j |dd} t| } | D]}| j j |ddqˆ |  | t | dkr|r|jkr| d }j|}|j|fkrNtd |d |d |jtj||iid ||i}|jkr܈|nV|rfdd| D}ni}t||fdd| D\}jjD]}||<q| fdd|D| |q2D]8}||kr||kr|jkrj|||<qfddjD}| |fddjD}| ||D]H\}}tfdd|jDrfdd|jD}|j|d||<qjt|B}j|||dS)aSet Dataset (multi-)indexes using one or more existing coordinates or variables. This legacy method is limited to pandas (multi-)indexes and 1-dimensional "dimension" coordinates. See :py:meth:`~Dataset.set_xindex` for setting a pandas or a custom Xarray-compatible index from one or more arbitrary coordinates. Parameters ---------- indexes : {dim: index, ...} Mapping from names matching dimensions and values given by (lists of) the names of existing coordinates or variables to set as new (multi-)index. append : bool, default: False If True, append the supplied index(es) to the existing index(es). Otherwise replace the existing index(es) (default). **indexes_kwargs : optional The keyword arguments form of ``indexes``. One of indexes or indexes_kwargs must be provided. Returns ------- obj : Dataset Another dataset, with this dataset's data but replaced coordinates. Examples -------- >>> arr = xr.DataArray( ... data=np.ones((2, 3)), ... dims=["x", "y"], ... coords={"x": range(2), "y": range(3), "a": ("x", [3, 4])}, ... ) >>> ds = xr.Dataset({"v": arr}) >>> ds Dimensions: (x: 2, y: 3) Coordinates: * x (x) int64 0 1 * y (y) int64 0 1 2 a (x) int64 3 4 Data variables: v (x, y) float64 1.0 1.0 1.0 1.0 1.0 1.0 >>> ds.set_index(x="a") Dimensions: (x: 2, y: 3) Coordinates: * x (x) int64 3 4 * y (y) int64 0 1 2 Data variables: v (x, y) float64 1.0 1.0 1.0 1.0 1.0 1.0 See Also -------- Dataset.reset_index Dataset.set_xindex Dataset.swap_dims set_indexrcSsg|] }t|qSr)rrVrrrrsz%Dataset.set_index..z variable(s) do not existrOrPrrz7dimension mismatch: try setting an index for dimension z with variable z that has dimensions optionscsi|]}|j|qSrrrr rrrsz%Dataset.set_index..csi|]}|j|qSrrrr rrr!scsi|] }|qSrrrrrrr&scsi|]\}}|kr||qSrrrDrrrr2scsi|]\}}|kr||qSrrrDrrrr7sc3s|]}|kVqdSrrrE replace_dimsrrr>sz$Dataset.set_index..csg|]}||qSrrrEr|rrr?sr>rp)rMrrBrrrrr rrrrrRrr*rr1from_variablesrNrrr2Zfrom_variables_maybe_expandrrrrr{r~)rr3rruZ dim_coordsrrZ all_var_namesrZ _var_names var_namesZ invalid_varsZindex_coord_namesZall_index_coord_namesrrridx_varsZcurrent_variablesr@Zindexes_rrAZnew_dimsr2r)rrrr}rrrvs@                 zDataset.set_index)rdims_or_levelsrrcsttsttsgttj}|rBtt|dttt}i}ifdd}D]}j|}||krqr||tj |}  | t|t rb|j j } fdd| D|jkrLrL|} | fdd| D | tt s4 |fdd| Dn|j|| qr|| qrfd djD} | |fd djD} | j}j| || d S) aReset the specified index(es) or multi-index level(s). This legacy method is specific to pandas (multi-)indexes and 1-dimensional "dimension" coordinates. See the more generic :py:meth:`~Dataset.drop_indexes` and :py:meth:`~Dataset.set_xindex` method to respectively drop and set pandas or custom indexes for arbitrary coordinates. Parameters ---------- dims_or_levels : Hashable or Sequence of Hashable Name(s) of the dimension(s) and/or multi-index level(s) that will be reset. drop : bool, default: False If True, remove the specified indexes and/or multi-index levels instead of extracting them as new coordinates (default: False). Returns ------- obj : Dataset Another dataset, with this dataset's data but replaced coordinates. See Also -------- Dataset.set_index Dataset.set_xindex Dataset.drop_indexes z" are not coordinates with an indexcs0r|nfdd|D}|dS)Ncsi|]}|j|qSr)r rrr rrr|sz@Dataset.reset_index..drop_or_convert..)r)rZ base_vars)rrrrrrdrop_or_convertxs   z,Dataset.reset_index..drop_or_convertcs i|]}|kr|j|qSrrr)rrrrrsz'Dataset.reset_index..csi|] }|qSrrrryrrrscsg|]}|kr|qSrrr)keep_level_varsrrrsz'Dataset.reset_index..csi|]\}}|kr||qSrrrDrzrrrscsi|]\}}|kr||qSrrrDr{rrrsrp)rrrrr*rrrrrRrr2rrrZ keep_levelsrNrBr rr~)rrrinvalid_coordsseenrrrrZ idx_var_namesZ level_namesrr3rr2r)rrrrrrrrr reset_indexHsd!                   zDataset.reset_indexzstr | Sequence[Hashable]ztype[Index] | None)rr2 index_clsrc s*t|st|ts|g}|dkr8t|dkr2t}qPt}nt|tsPt|dt |j }|rdg}|t j }||}|r| d||r| d|dt d|t |t j@}|rt d |fd d |D} |j| |d } | | } t| tr | jgt|}t|dkrnj } j} t|}|| krd| || |<| | |<ni} j D]\}}||kr||| |<q|i} jD]\}}||kr|| |<q|D]D}z| || |<Wn$tk rj || |<YnX| | |<qʈj| j t |B| d S)aSet a new, Xarray-compatible index from one or more existing coordinate(s). Parameters ---------- coord_names : str or list Name(s) of the coordinate(s) used to build the index. If several names are given, their order matters. index_cls : subclass of :class:`~xarray.indexes.Index`, optional The type of index to create. By default, try setting a ``PandasIndex`` if ``len(coord_names) == 1``, otherwise a ``PandasMultiIndex``. **options Options passed to the index constructor. Returns ------- obj : Dataset Another dataset, with this dataset's data and with a new index. Nrz" is not a subclass of xarray.Indexzinvalid coordinate(s)zthose variables don't exist: z$those variables are data variables: z, use `set_coords` firstrz)those coordinates already have an index: csi|]}|j|qSrrrr rrrsz&Dataset.set_xindex..rwr)rPrrrr1r2 issubclassr/r rrr rrrr*r~rNrrrsrrBrr{)rr2rrxrrZno_varsr,Zindexed_coordsrrZnew_coord_varsrr3rrrrr r set_xindexsp                 zDataset.set_xindexz-Mapping[Any, Sequence[int | Hashable]] | NonezSequence[int | Hashable])r dim_orderdim_order_kwargsrc  st||d}j}tj}ii|D]t\}}j|}t|ts\td|dfdd|D}| | |}  fdd| D | q0fddjD}| fddjD}| j ||d S) aRearrange index levels using input order. Parameters ---------- dim_order : dict-like of Hashable to Sequence of int or Hashable, optional Mapping from names matching dimensions and values given by lists representing new level orders. Every given dimension must have a multi-index. **dim_order_kwargs : Sequence of int or Hashable, optional The keyword arguments form of ``dim_order``. One of dim_order or dim_order_kwargs must be provided. Returns ------- obj : Dataset Another dataset, with this dataset's data but replaced coordinates. reorder_levelsz coordinate z has no MultiIndexcsi|]}|j|qSrrrr rrrJsz*Dataset.reorder_levels..csi|] }|qSrrrryrrrMscsi|]\}}|kr||qSrrrD)rrrrPscsi|]\}}|kr||qSrrrD)rrrrSsr) rMr rsrr*rBrr2rrrNrr{) rrrrr3rorderrZ level_varsrr)rrrrrr's&          zDataset.reorder_levelsz-tuple[Index | None, dict[Hashable, Variable]]c Csd}i}|jD]\}}|j|}|jdkr|jd|kr|sL|j|r`|rt|jt jk r|dk r||k r|rt d|ddifS|}|||<q|r|dkr||jkr|j|}nt |j||j\} } }t dg|}||i}||fS)aUsed by stack and unstack to get one pandas (multi-)index among the indexed coordinates along dimension `dim`. If exactly one index is found, return it with its corresponding coordinate variables(s), otherwise return None and an empty dict. If `create_index=True`, create a new index if none is found or raise an error if multiple indexes are found. Nrrzcannot stack dimension zQ with `create_index=True` and with more than one index found along that dimension) r*rBr rrrZis_multirJunstackr/rrr1) rrmulti create_indexZ stack_indexZ stack_coordsrrrr4rrr_get_stack_indexXs>            zDataset._get_stack_indexzSequence[Hashable | ellipsis]z type[Index])rrnew_dimrrrcs|dkrtdd|kr(tt|j}i}g}gjD]\}tfdd|Drfdd|D}tj|} fdd| D} | | } | jf||i} | ||<| |q>j dd ||<q>|D]}tj j |d d 7qi} t j}|s|dkri}|D],}j||d \}dk r||qt|t|kr|||| |<| fd d|D|}|D]}||dq||||fddjD}|| j|||dS)N.z/Please use [...] for dims, rather than just ...c3s|]}|jkVqdSrr>rErrrrsz&Dataset._stack_once..csg|]}|jkr|qSrr>rErrrrs z'Dataset._stack_once..csg|]}j|qSrr>rEr rrrsFrqrOrP)rcsi|] }|qSrrrryrrrsz'Dataset._stack_once..csi|]\}}|kr||qSrrrDrzrrrsrp)rrrNrrrBrrsstackrrsrrRrrrrrrNrr*r~)rrrrrrZstacked_var_namesrZadd_dimsZvdimsrZexp_varZ stacked_varrrZ product_varsrrrr3r)rrrrr _stack_oncesV         zDataset._stack_oncez2Mapping[Any, Sequence[Hashable | ellipsis]] | None)r dimensionsrrdimensions_kwargsrcKs6t||d}|}|D]\}}|||||}q|S)a Stack any number of existing dimensions into a single new dimension. New dimensions will be added at the end, and by default the corresponding coordinate variables will be combined into a MultiIndex. Parameters ---------- dimensions : mapping of hashable to sequence of hashable Mapping of the form `new_name=(dim1, dim2, ...)`. Names of new dimensions, and the existing dimensions that they replace. An ellipsis (`...`) will be replaced by all unlisted dimensions. Passing a list containing an ellipsis (`stacked_dim=[...]`) will stack over all dimensions. create_index : bool or None, default: True - True: create a multi-index for each of the stacked dimensions. - False: don't create any index. - None. create a multi-index only if exactly one single (1-d) coordinate index is found for every dimension to stack. index_cls: Index-class, default: PandasMultiIndex Can be used to pass a custom multi-index type (must be an Xarray index that implements `.stack()`). By default, a pandas multi-index wrapper is used. **dimensions_kwargs The keyword arguments form of ``dimensions``. One of dimensions or dimensions_kwargs must be provided. Returns ------- stacked : Dataset Dataset with stacked data. See Also -------- Dataset.unstack r)rMrBr)rrrrrrrrrrrrs , z Dataset.stackrzCollection[Hashable])r sample_dims variable_dimrrc sddlm}tfddjDD]0}|j}tt|k}|s(td|q(fddfdd jD} || d } |d k r|| _| S) aCombine variables of differing dimensionality into a DataArray without broadcasting. This method is similar to Dataset.to_array but does not broadcast the variables. Parameters ---------- new_dim : hashable Name of the new stacked coordinate sample_dims : Collection of hashables List of dimensions that **will not** be stacked. Each array in the dataset must share these dimensions. For machine learning applications, these define the dimensions over which samples are drawn. variable_dim : hashable, default: "variable" Name of the level in the stacked coordinate which corresponds to the variables. name : hashable, optional Name of the new data array. Returns ------- stacked : DataArray DataArray with the specified dimensions and data variables stacked together. The stacked coordinate is named ``new_dim`` and represented by a MultiIndex object with a level containing the data variable names. The name of this level is controlled using the ``variable_dim`` argument. See Also -------- Dataset.to_array Dataset.stack DataArray.to_unstacked_dataset Examples -------- >>> data = xr.Dataset( ... data_vars={ ... "a": (("x", "y"), [[0, 1, 2], [3, 4, 5]]), ... "b": ("x", [6, 7]), ... }, ... coords={"y": ["u", "v", "w"]}, ... ) >>> data Dimensions: (x: 2, y: 3) Coordinates: * y (y) >> data.to_stacked_array("z", sample_dims=["x"]) array([[0, 1, 2, 6], [3, 4, 5, 7]]) Coordinates: * z (z) object MultiIndex * variable (z) object 'a' 'a' 'a' 'b' * y (z) object 'u' 'v' 'w' nan Dimensions without coordinates: x r)concatc3s|]}|kr|VqdSrrr)rrrrHsz+Dataset.to_stacked_array..z.ensure_stackablecsg|]}|qSrrr )rrrrresz,Dataset.to_stacked_array..rmN) Zxarray.core.concatrrrrrrr,r) rrrrrrrrZdims_include_sample_dimsZstackable_vars data_arrayr)rrrrrrrto_stacked_arrays"J   zDataset.to_stacked_arrayz&tuple[Index, dict[Hashable, Variable]])rrindex_and_varsr6rcs|\}}i}fdd|jD}|\} } || | D]\} } || |qB|jD]R\} } | |krf| jkrt|tr|| }n|}| j | ||d|| <qf| || <qft |j ht | B}|j |||dS)Ncsi|]\}}|kr||qSrrrDrmrrrvsz)Dataset._unstack_once..)rrr1r6rp) r*rBrrrNrrrr _unstack_oncerrr~)rrrr1r6rrrr3r clean_indexrrr fill_value_r2rrmrrms4       zDataset._unstack_oncecsF|\}}i}fdd|jD}|\} } || i} | D]\} } | | |qFdd| D}|| tjj| j| j d}| |r|}n:t |t fdd|D|}|j |d||d}|jD]8\} }| |kr|jkr||i|| <q||| <qt|jht|B}|j|||dS) Ncsi|]\}}|kr||qSrrrDrmrrrsz1Dataset._unstack_full_reindex..cSsi|]\}}||jqSrrrDrrrrsrcsi|] }|qSrrr) xr_full_idxrrrsFr5rp)r*rBrrrNr MultiIndexZ from_productlevelsrrr2r0r<rrrrr~)rrrr1r6rrrr3rrZnew_index_variablesrrZ new_dim_sizesZfull_idxrrrr2r)rrr_unstack_full_reindexsL       zDataset._unstack_full_reindex)rrr1r6rcsT|dkrtj}nHt|ts(t|ts0|g}nt|}fdd|D}|r\td|i}|D]*}j|dd\}} |dk rd|| f||<qd|dkrt|}n&t|t|} | rtdt| j dd } fd dtj tj D} t d t fd d | D} |D]6}| r8| |||||} n| |||||} q| S)aZ Unstack existing dimensions corresponding to MultiIndexes into multiple new dimensions. New dimensions will be added at the end. Parameters ---------- dim : str, Iterable of Hashable or None, optional Dimension(s) over which to unstack. By default unstacks all MultiIndexes. fill_value : scalar or dict-like, default: nan value to be filled. If a dict-like, maps variable names to fill values. If not provided or if the dict-like does not contain all variables, the dtype's NA value will be used. sparse : bool, default: False use sparse-array if True Returns ------- unstacked : Dataset Dataset with unstacked data. See Also -------- Dataset.stack Ncsg|]}|jkr|qSrr>rEr rrrs z#Dataset.unstack..)Dataset does not contain the dimensions: T)rzDcannot unstack dimensions that do not have exactly one multi-index: Frqcsg|]}j|qSrrrr rrrsr6c3s4|],}t|jp*t|jp*t|jtj VqdSr)rCrrrr rV)sparse_array_typerrrs   z"Dataset.unstack..)rrrrrrrrrrsrr*rBrrr)rrr1r6rrZstacked_indexesrFrrZnon_multi_dimsrZ nonindexesZneeds_full_reindexr)rrrrsP"      zDataset.unstackrb)rrrcCs"t||}|jfddi|S)a1Update this dataset's variables with those from another dataset. Just like :py:meth:`dict.update` this is a in-place operation. For a non-inplace version, see :py:meth:`Dataset.merge`. Parameters ---------- other : Dataset or mapping Variables with which to update this dataset. One of: - Dataset - mapping {var name: DataArray} - mapping {var name: Variable} - mapping {var name: (dimension name, array-like)} - mapping {var name: (tuple of dimension names, array-like)} Returns ------- updated : Dataset Updated dataset. Note that since the update is in-place this is the input dataset. It is deprecated since version 0.17 and scheduled to be removed in 0.21. Raises ------ ValueError If any dimensions would have inconsistent sizes in the updated dataset. See Also -------- Dataset.assign Dataset.merge rzT)r<r{_asdict)rr merge_resultrrrr.s$ zDataset.updateZ no_conflictsr-overridezCoercibleMapping | DataArrayrjrqri)rroverwrite_varsr1rr1 combine_attrsrc CsHddlm}t||r|n|}t|||||||d}|jf|S)a Merge the arrays of two datasets into a single dataset. This method generally does not allow for overriding data, with the exception of attributes, which are ignored on the second dataset. Variables with the same name are checked for conflicts via the equals or identical methods. Parameters ---------- other : Dataset or mapping Dataset or variables to merge with this dataset. overwrite_vars : hashable or iterable of hashable, optional If provided, update variables of these name(s) without checking for conflicts in this dataset. compat : {"identical", "equals", "broadcast_equals", "no_conflicts", "override", "minimal"}, default: "no_conflicts" String indicating how to compare variables of the same name for potential conflicts: - 'identical': all values, dimensions and attributes must be the same. - 'equals': all values and dimensions must be the same. - 'broadcast_equals': all values must be equal when variables are broadcast against each other to ensure common dimensions. - 'no_conflicts': only values which are not null in both datasets must be equal. The returned dataset then contains the combination of all non-null values. - 'override': skip comparing and pick variable from first dataset - 'minimal': drop conflicting coordinates join : {"outer", "inner", "left", "right", "exact", "override"}, default: "outer" Method for joining ``self`` and ``other`` along shared dimensions: - 'outer': use the union of the indexes - 'inner': use the intersection of the indexes - 'left': use indexes from ``self`` - 'right': use indexes from ``other`` - 'exact': error instead of aligning non-equal indexes - 'override': use indexes from ``self`` that are the same size as those of ``other`` in that dimension fill_value : scalar or dict-like, optional Value to use for newly missing values. If a dict-like, maps variable names (including coordinates) to fill values. combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", "override"} or callable, default: "override" A callable or a 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. If a callable, it must expect a sequence of ``attrs`` dicts and a context object as its only parameters. Returns ------- merged : Dataset Merged dataset. Raises ------ MergeError If any variables conflict (see ``compat``). See Also -------- Dataset.update rr^)rr1rr1r)rr_rrr;r{r) rrrr1rr1rr_rrrrrQUsU  z Dataset.merge)r virtual_okayrcCs0t|t|j}|r ||j8}|r,tddS)NzFOne or more of the specified variables cannot be found in this dataset)rr Zvirtual_variablesr)rrrZ bad_namesrrrrs zDataset._assert_all_in_datasetrPrn)rrrQrc ststtshnt|dkr4|t}D]F}|j|d}t|tr>t|jj |j g}|t}| |q>|rt|Ot j d|dtddt|jfdd|jDfd d |jD}fd d|jD} |j|| d S) aDrop variables from this dataset. Parameters ---------- names : hashable or iterable of hashable Name(s) of variables to drop. errors : {"raise", "ignore"}, default: "raise" If 'raise', raises a ValueError error if any of the variable passed are not in the dataset. If 'ignore', any given names that are in the dataset are dropped and no error is raised. Returns ------- dropped : Dataset rNzDeleting a single level of a MultiIndex is deprecated. Previously, this deleted all levels of a MultiIndex. Please also drop the following variables: z! to avoid an error in the future.rracsi|]\}}|kr||qSrrrDrrrrsz%Dataset.drop_vars..csh|]}|kr|qSrrrrrrrisz$Dataset.drop_vars..csi|]\}}|kr||qSrrrDrrrrsrp)rPrrrrr*rr2rrrrrrDeprecationWarningr3rr rBrr~) rrrQZ other_namesrZ maybe_midxZidx_coord_namesZidx_other_namesr2r3r)rrr drop_varss8       zDataset.drop_vars)rr2rQrc ststtshnt|dkrj|j}|rFtd|tt|j}|rjtd|t|jddi}|j D]&\}}|kr| ||<q|||<qfdd|j D}|j ||dS) a8Drop the indexes assigned to the given coordinates. Parameters ---------- coord_names : hashable or iterable of hashable Name(s) of the coordinate(s) for which to drop the index. errors : {"raise", "ignore"}, default: "raise" If 'raise', raises a ValueError error if any of the coordinates passed have no index or are not in the dataset. If 'ignore', no error is raised. Returns ------- dropped : Dataset A new dataset with dropped indexes. rzthose coordinates don't exist: z(those coordinates do not have an index: zremove index(es))actioncsi|]\}}|kr||qSrrrDr2rrr-sz(Dataset.drop_indexes..)rr3) rPrrrrrr*r3rr rBrr{) rr2rQrZunindexed_coordsrrrr3rrrrs(  zDataset.drop_indexes)rrQrcKs|dkrtdt|r@t|ts@tjdtdd|j||dS|sNt|trj|dk r^tdt||d }|dkrt |st|t rtjd t dd|j||dS|dk rtjd t dd|j ||ifd |i|Stjd t dd|j ||dS)zBackward compatible method based on `drop_vars` and `drop_sel` Using either `drop_vars` or `drop_sel` is encouraged See Also -------- Dataset.drop_vars Dataset.drop_sel rrO)errors must be either "raise" or "ignore"zBdropping coordinates using `drop` is be deprecated; use drop_vars.rrarPNz+cannot specify dim and dict-like arguments.rzRdropping variables using `drop` will be deprecated; using drop_vars is encouraged.zdropping labels using list-like labels is deprecated; using dict-like arguments with `drop_sel`, e.g. `ds.drop_sel(dim=[labels]).rQzNdropping labels using `drop` will be deprecated; using drop_sel is encouraged.)rrOrrrrrrrMrPrPendingDeprecationWarningrdrop_sel)rlabelsrrQ labels_kwargsrrrr1sB z Dataset.dropc Ks|dkrtdt||d}|}|D]r\}}t|r@|g}t|}z||}Wn$tk r|td|dYnX|j ||d}|j ||i}q(|S)a%Drop index labels from this dataset. Parameters ---------- labels : mapping of hashable to Any Index labels to drop errors : {"raise", "ignore"}, default: "raise" If 'raise', raises a ValueError error if any of the index labels passed are not in the dataset. If 'ignore', any given labels that are in the dataset are dropped and no error is raised. **labels_kwargs : {dim: label, ...}, optional The keyword arguments form of ``dim`` and ``labels`` Returns ------- dropped : Dataset Examples -------- >>> data = np.arange(6).reshape(2, 3) >>> labels = ["a", "b", "c"] >>> ds = xr.Dataset({"A": (["x", "y"], data), "y": labels}) >>> ds Dimensions: (x: 2, y: 3) Coordinates: * y (y) >> ds.drop_sel(y=["a", "c"]) Dimensions: (x: 2, y: 1) Coordinates: * y (y) >> ds.drop_sel(y="b") Dimensions: (x: 2, y: 2) Coordinates: * y (y) \}}t|r4|g}t|}||}||}|||<q|j|}|S)aBDrop index positions from this Dataset. Parameters ---------- indexers : mapping of hashable to Any Index locations to drop **indexers_kwargs : {dim: position, ...}, optional The keyword arguments form of ``dim`` and ``positions`` Returns ------- dropped : Dataset Raises ------ IndexError Examples -------- >>> data = np.arange(6).reshape(2, 3) >>> labels = ["a", "b", "c"] >>> ds = xr.Dataset({"A": (["x", "y"], data), "y": labels}) >>> ds Dimensions: (x: 2, y: 3) Coordinates: * y (y) >> ds.drop_isel(y=[0, 2]) Dimensions: (x: 2, y: 1) Coordinates: * y (y) >> ds.drop_isel(y=1) Dimensions: (x: 2, y: 2) Coordinates: * y (y) .) rrrrrrr rBr)rrrQrrrrrrszDataset.drop_dims)rrrrcst|dkrLt|dtrLdd|dD}tdd|d|ddt|dkrjtt||j|}|}|j D].\}t fdd |D}j ||j|<q||S) aReturn a new Dataset object with all array dimensions transposed. Although the order of dimensions on each array will change, the dataset dimensions themselves will remain in fixed (sorted) order. Parameters ---------- *dims : hashable, optional By default, reverse the dimensions on each array. 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 Dataset: - "raise": raise an exception - "warn": raise a warning, and ignore the missing dimensions - "ignore": ignore the missing dimensions Returns ------- transposed : Dataset Each array in the dataset (including) coordinates will be transposed to the given order. Notes ----- This operation returns a view of each array's data. It is lazy for dask-backed DataArrays but not for numpy-backed DataArrays -- the data will be fully loaded into memory. See Also -------- numpy.transpose DataArray.transpose rcSs&g|]}t|trt|n|qSr)rrrrrrrrCsz%Dataset.transpose..zFtranspose requires dims to be passed as multiple arguments. Expected `rz `. Received `z ` insteadc3s |]}|jdkr|VqdS)).Nr>rrrrrNsz$Dataset.transpose..) rrrr rrNrrsr rBr transpose)rrrZlist_fixr4rSrZvar_dimsrrrrs( zDataset.transposerzLiteral[('any', 'all')])rrhowthreshsubsetrc sjkrtd|dkr*tj}tjjtjd}td}|D]\}j|}|jkrNfdd|jD} |t | | 7}|t fdd| D7}qN|dk r||k} nD|dkr||k} n2|d kr|dk} n |dk rtd |nt d | iS) a&Returns a new dataset with dropped labels for missing values along the provided dimension. Parameters ---------- dim : hashable Dimension along which to drop missing values. Dropping along multiple dimensions simultaneously is not yet supported. how : {"any", "all"}, default: "any" - any : if any NA values are present, drop that label - all : if all values are NA, drop that label thresh : int or None, optional If supplied, require this many non-NA values. subset : iterable of hashable or None, optional Which variables to check for missing values. By default, all variables in the dataset are checked. Returns ------- Dataset z# must be a single dataset dimensionNrrcsg|]}|kr|qSrrrErmrrrsz"Dataset.dropna..csg|]}j|qSrr>rEr rrrsrrMzinvalid how option: zmust specify how or thresh)rrrer,rzerosrint_r rcountmathprodr r) rrrrrrrrrrmaskr)rrrdropnaRs,!        zDataset.dropna)rr#rcCsHt|r8t|d|}t|t|jks8tdt||}|S)u Fill missing values in this object. This operation follows the normal broadcasting and alignment rules that xarray uses for binary arithmetic, except the result is aligned to this object (``join='left'``) instead of aligned to the intersection of index coordinates (``join='inner'``). Parameters ---------- value : scalar, ndarray, DataArray, dict or Dataset Used to fill all matching missing values in this dataset's data variables. Scalars, ndarrays or DataArrays arguments are used to fill all data with aligned coordinates (for DataArrays). Dictionaries or datasets match data variables and then align coordinates if necessary. Returns ------- Dataset Examples -------- >>> ds = xr.Dataset( ... { ... "A": ("x", [np.nan, 2, np.nan, 0]), ... "B": ("x", [3, 4, np.nan, 1]), ... "C": ("x", [np.nan, np.nan, np.nan, 5]), ... "D": ("x", [np.nan, 3, np.nan, 4]), ... }, ... coords={"x": [0, 1, 2, 3]}, ... ) >>> ds Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 Data variables: A (x) float64 nan 2.0 nan 0.0 B (x) float64 3.0 4.0 nan 1.0 C (x) float64 nan nan nan 5.0 D (x) float64 nan 3.0 nan 4.0 Replace all `NaN` values with 0s. >>> ds.fillna(0) Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 Data variables: A (x) float64 0.0 2.0 0.0 0.0 B (x) float64 3.0 4.0 0.0 1.0 C (x) float64 0.0 0.0 0.0 5.0 D (x) float64 0.0 3.0 0.0 4.0 Replace all `NaN` elements in column ‘A’, ‘B’, ‘C’, and ‘D’, with 0, 1, 2, and 3 respectively. >>> values = {"A": 0, "B": 1, "C": 2, "D": 3} >>> ds.fillna(value=values) Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 Data variables: A (x) float64 0.0 2.0 0.0 0.0 B (x) float64 3.0 4.0 1.0 1.0 C (x) float64 2.0 2.0 2.0 5.0 D (x) float64 3.0 3.0 3.0 4.0 r,zSall variables in the argument to `fillna` must be contained in the original dataset) r!rOrrprr,rr fillna)rr#Z value_keysoutrrrrsF  zDataset.fillnazbool | HashablezFint | float | str | pd.Timedelta | np.timedelta64 | datetime.timedelta)rrrlimituse_coordinatemax_gaprFrc Ks2ddlm}m}|||f|||||d|} | S)aFill in NaNs by interpolating according to different methods. Parameters ---------- dim : Hashable or None, optional Specifies the dimension along which to interpolate. method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", "barycentric", "krog", "pchip", "spline", "akima"}, default: "linear" String indicating which method to use for interpolation: - 'linear': linear interpolation. Additional keyword arguments are passed to :py:func:`numpy.interp` - 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial': are passed to :py:func:`scipy.interpolate.interp1d`. If ``method='polynomial'``, the ``order`` keyword argument must also be provided. - 'barycentric', 'krog', 'pchip', 'spline', 'akima': use their respective :py:class:`scipy.interpolate` classes. use_coordinate : bool or Hashable, default: True Specifies which index to use as the x values in the interpolation formulated as `y = f(x)`. If False, values are treated as if eqaully-spaced along ``dim``. If True, the IndexVariable `dim` is used. If ``use_coordinate`` is a string, it specifies the name of a coordinate variariable to use as the index. limit : int, default: None Maximum number of consecutive NaNs to fill. Must be greater than 0 or None for no limit. This filling is done regardless of the size of the gap in the data. To only interpolate over gaps less than a given length, see ``max_gap``. max_gap : int, float, str, pandas.Timedelta, numpy.timedelta64, datetime.timedelta, default: None Maximum size of gap, a continuous sequence of NaNs, that will be filled. Use None for no limit. When interpolating along a datetime64 dimension and ``use_coordinate=True``, ``max_gap`` can be one of the following: - a string that is valid input for pandas.to_timedelta - a :py:class:`numpy.timedelta64` object - a :py:class:`pandas.Timedelta` object - a :py:class:`datetime.timedelta` object Otherwise, ``max_gap`` must be an int or a float. Use of ``max_gap`` with unlabeled dimensions has not been implemented yet. Gap length is defined as the difference between coordinate values at the first data point after a gap and the last value before a gap. For gaps at the beginning (end), gap length is defined as the difference between coordinate values at the first (last) valid data point and the first (last) NaN. For example, consider:: array([nan, nan, nan, 1., nan, nan, 4., nan, nan]) Coordinates: * x (x) int64 0 1 2 3 4 5 6 7 8 The gap lengths are 3-0 = 3; 6-3 = 3; and 8-6 = 2 respectively **kwargs : dict, optional parameters passed verbatim to the underlying interpolation function Returns ------- interpolated: Dataset Filled in Dataset. See Also -------- numpy.interp scipy.interpolate Examples -------- >>> ds = xr.Dataset( ... { ... "A": ("x", [np.nan, 2, 3, np.nan, 0]), ... "B": ("x", [3, 4, np.nan, 1, 7]), ... "C": ("x", [np.nan, np.nan, np.nan, 5, 0]), ... "D": ("x", [np.nan, 3, np.nan, -1, 4]), ... }, ... coords={"x": [0, 1, 2, 3, 4]}, ... ) >>> ds Dimensions: (x: 5) Coordinates: * x (x) int64 0 1 2 3 4 Data variables: A (x) float64 nan 2.0 3.0 nan 0.0 B (x) float64 3.0 4.0 nan 1.0 7.0 C (x) float64 nan nan nan 5.0 0.0 D (x) float64 nan 3.0 nan -1.0 4.0 >>> ds.interpolate_na(dim="x", method="linear") Dimensions: (x: 5) Coordinates: * x (x) int64 0 1 2 3 4 Data variables: A (x) float64 nan 2.0 3.0 1.5 0.0 B (x) float64 3.0 4.0 2.5 1.0 7.0 C (x) float64 nan nan nan 5.0 0.0 D (x) float64 nan 3.0 1.0 -1.0 4.0 >>> ds.interpolate_na(dim="x", method="linear", fill_value="extrapolate") Dimensions: (x: 5) Coordinates: * x (x) int64 0 1 2 3 4 Data variables: A (x) float64 1.0 2.0 3.0 1.5 0.0 B (x) float64 3.0 4.0 2.5 1.0 7.0 C (x) float64 20.0 15.0 10.0 5.0 0.0 D (x) float64 5.0 3.0 1.0 -1.0 4.0 r)_apply_over_vars_with_dim interp_na)rrrrr)xarray.core.missingrr) rrrrrrrFrrrurrrinterpolate_nasy zDataset.interpolate_na)rrrrcCs$ddlm}m}|||||d}|S)aFill NaN values by propagating values forward *Requires bottleneck.* Parameters ---------- dim : Hashable Specifies the dimension along which to propagate values when filling. limit : int or None, optional The maximum number of consecutive NaN values to forward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. Must be greater than 0 or None for no limit. Must be None or greater than or equal to axis length if filling along chunked axes (dimensions). Returns ------- Dataset r)rffillrr)rrr)rrrrrrurrrrgsz Dataset.ffillcCs$ddlm}m}|||||d}|S)aFill NaN values by propagating values backward *Requires bottleneck.* Parameters ---------- dim : Hashable Specifies the dimension along which to propagate values when filling. limit : int or None, optional The maximum number of consecutive NaN values to backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. Must be greater than 0 or None for no limit. Must be None or greater than or equal to axis length if filling along chunked axes (dimensions). Returns ------- Dataset r)rbfillr)rrr)rrrrrrurrrrsz Dataset.bfillcCstj||ddd}|S)aCombine two Datasets, default to data_vars of self. The new coordinates follow the normal broadcasting and alignment rules of ``join='outer'``. Vacant cells in the expanded coordinates are filled with np.nan. Parameters ---------- other : Dataset Used to fill all matching missing values in this array. Returns ------- Dataset r-)rZ dataset_join)r r)rrrrrr combine_firstszDataset.combine_first) keep_attrskeepdims numeric_onlyr )rrrrrrrFrc s|dddk rtd|dks(|dkr4tjn$t|tsHt|tsP|hnt|fddD}|r|td||dkrtdd }ij D]\}} fd d| jD} |j kr| s| |<q| r|rt | j t js| j t jkrt| | jkr| jd krdn| } | j|f| ||d ||<qfd dj D} fddj D} |rpjnd}j| || dS)aaReduce this dataset by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `f(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. keep_attrs : bool or None, optional If True, the dataset'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. Coordinates that use these dimensions are removed. numeric_only : bool, default: False If True, only apply ``func`` to variables with a numeric dtype. **kwargs : Any Additional keyword arguments passed on to ``func``. Returns ------- reduced : Dataset Dataset with this object's DataArrays replaced with new DataArrays of summarized data and the indicated dimension(s) removed. rjNzPpassing 'axis' to Dataset reduce methods is ambiguous. Please use 'dim' instead..csg|]}|jkr|qSrr>rEr rrrs z"Dataset.reduce..rFrcsg|]}|kr|qSrrrEr>rrrsr)rrrcsh|]}|kr|qSrrrrrrri sz!Dataset.reduce..csi|]\}}|kr||qSrrrDrrrr sz"Dataset.reduce..r2r.r3)rrrrrrrrAr rBr-r issubdtypernumberbool_rrreducer*r.r~)rrrrrrrFZmissing_dimensionsrr reduce_dimsZreduce_maybe_singler2r3r.rrrrrrsl(       zDataset.reducerz Iterable[Any])rrrrrFrc  sr|dkrtdd}fdd|jD}|rT|D]\}}||j|q:|r^|jnd}t|||dS)acApply a function to each data variable in this dataset Parameters ---------- func : callable Function which can be called in the form `func(x, *args, **kwargs)` to transform each DataArray `x` in this dataset into another DataArray. keep_attrs : bool or None, optional If True, both the dataset's and variables' attributes (`attrs`) will be copied from the original objects to the new ones. If False, the new dataset and variables will be returned without copying the attributes. args : iterable, optional Positional arguments passed on to `func`. **kwargs : Any Keyword arguments passed on to `func`. Returns ------- applied : Dataset Resulting dataset from applying ``func`` to each data variable. Examples -------- >>> da = xr.DataArray(np.random.randn(2, 3)) >>> ds = xr.Dataset({"foo": da, "bar": ("x", [-1, 2])}) >>> ds Dimensions: (dim_0: 2, dim_1: 3, x: 2) Dimensions without coordinates: dim_0, dim_1, x Data variables: foo (dim_0, dim_1) float64 1.764 0.4002 0.9787 2.241 1.868 -0.9773 bar (x) int64 -1 2 >>> ds.map(np.fabs) Dimensions: (dim_0: 2, dim_1: 3, x: 2) Dimensions without coordinates: dim_0, dim_1, x Data variables: foo (dim_0, dim_1) float64 1.764 0.4002 0.9787 2.241 1.868 0.9773 bar (x) float64 1.0 2.0 NFrcs(i|] \}}|t||fqSr)rQrDrrrFrrrEszDataset.map..r6)rAr,rB_copy_attrs_fromr.rJ) rrrrrFrrrAr.rrrrs0 z Dataset.mapcKs"tjdtdd|j|||f|S)zv Backward compatible implementation of ``map`` See Also -------- Dataset.map zNDataset.apply may be deprecated in the future. Using Dataset.map is encouragedrra)rrrr)rrrrrFrrrapplyOs z Dataset.apply)rrvariables_kwargsrcKs@t||d}|}||}|jt||||S)az Assign new data variables to a Dataset, returning a new object with all the original variables in addition to the new ones. Parameters ---------- variables : mapping of hashable to Any Mapping from variables names to the new values. If the new values are callable, they are computed on the Dataset and assigned to new data variables. If the values are not callable, (e.g. a DataArray, scalar, or array), they are simply assigned. **variables_kwargs The keyword arguments form of ``variables``. One of variables or variables_kwargs must be provided. Returns ------- ds : Dataset A new Dataset with the new variables in addition to all the existing variables. Notes ----- Since ``kwargs`` is a dictionary, the order of your arguments may not be preserved, and so the order of the new variables is not well defined. Assigning multiple variables within the same ``assign`` is possible, but you cannot reference other variables created within the same ``assign`` call. See Also -------- pandas.DataFrame.assign Examples -------- >>> x = xr.Dataset( ... { ... "temperature_c": ( ... ("lat", "lon"), ... 20 * np.random.rand(4).reshape(2, 2), ... ), ... "precipitation": (("lat", "lon"), np.random.rand(4).reshape(2, 2)), ... }, ... coords={"lat": [10, 20], "lon": [150, 160]}, ... ) >>> x Dimensions: (lat: 2, lon: 2) Coordinates: * lat (lat) int64 10 20 * lon (lon) int64 150 160 Data variables: temperature_c (lat, lon) float64 10.98 14.3 12.06 10.9 precipitation (lat, lon) float64 0.4237 0.6459 0.4376 0.8918 Where the value is a callable, evaluated on dataset: >>> x.assign(temperature_f=lambda x: x.temperature_c * 9 / 5 + 32) Dimensions: (lat: 2, lon: 2) Coordinates: * lat (lat) int64 10 20 * lon (lon) int64 150 160 Data variables: temperature_c (lat, lon) float64 10.98 14.3 12.06 10.9 precipitation (lat, lon) float64 0.4237 0.6459 0.4376 0.8918 temperature_f (lat, lon) float64 51.76 57.75 53.7 51.62 Alternatively, the same behavior can be achieved by directly referencing an existing dataarray: >>> x.assign(temperature_f=x["temperature_c"] * 9 / 5 + 32) Dimensions: (lat: 2, lon: 2) Coordinates: * lat (lat) int64 10 20 * lon (lon) int64 150 160 Data variables: temperature_c (lat, lon) float64 10.98 14.3 12.06 10.9 precipitation (lat, lon) float64 0.4237 0.6459 0.4376 0.8918 temperature_f (lat, lon) float64 51.76 57.75 53.7 51.62 assign)rMrsZ_calc_assign_resultsr-Z_maybe_drop_multiindex_coordsrrpr)rrrrrdrrrrds V   zDataset.assign)rrrc sddlm}fddjD}t|}tjdd|Ddd}|f|dj}t||jdd}d d j D} t j t | } ttj|} | | |<| | ||| || S) aConvert this dataset into an xarray.DataArray The data variables of this dataset will be broadcast against each other and stacked along the first axis of the new array. All coordinates of this dataset will remain coordinates. Parameters ---------- dim : Hashable, default: "variable" Name of the new dimension. name : Hashable or None, optional Name of the new data array. Returns ------- array : xarray.DataArray rr^csg|]}j|qSrrrr rrrsz$Dataset.to_array..cSsg|] }|jqSrr)rrrrrrsrjT)rcSsi|]\}}||jqSr)rrDrrrrsz$Dataset.to_array..)rr_r,rUrrrrSr.r-rBr5r*rr1rrrNrg) rrrr_r,Zbroadcast_varsrrrr-r3Z new_dim_indexrr rto_arrays zDataset.to_arrayzSequence[Hashable] | None)rrcsR|dkrtj}n(t|tjkrrr rrrsz0Dataset._normalize_dim_order..)rrrrrrr ordered_dimsrr r_normalize_dim_orders zDataset._normalize_dim_orderzpd.Series | pd.DataFramecCsRt|jdkr&tdd|DSt|jdkr<|Stdt|jdS)a<Convert this dataset into a pandas object without changing the number of dimensions. The type of the returned object depends on the number of Dataset dimensions: * 0D -> `pandas.Series` * 1D -> `pandas.DataFrame` Only works for Datasets with 1 or fewer dimensions. rcSsi|]\}}||qSr)itemrDrrrrsz%Dataset.to_pandas..rzcannot convert Datasets with %s dimensions into pandas objects without changing the number of dimensions. Please use Dataset.to_dataframe() instead.N)rrrZSeriesrB to_dataframerr rrr to_pandass zDataset.to_pandaszMapping[Any, int]rcsNfddjD}fdd|D}j}tjtt|||dS)Ncsg|]}|jkr|qSrr>rr rrrs z)Dataset._to_dataframe..cs$g|]}j|jdqS)r)r rsrreshaperrrrrrsr)rr-Zto_indexrr|rr)rrcolumnsrrrrr _to_dataframes  zDataset._to_dataframez pd.DataFramecCs|j|d}|j|dS)aConvert this dataset into a pandas.DataFrame. Non-index variables in this dataset form the columns of the DataFrame. The DataFrame is indexed by the Cartesian product of this dataset's indices. Parameters ---------- dim_order: Sequence of Hashable or None, optional Hierarchical dimension order for the resulting dataframe. All arrays are transposed to this order and then written out as flat vectors in contiguous order, so the last dimension in this list will be contiguous in the resulting DataFrame. This has a major influence on which operations are efficient on the resulting dataframe. If provided, must include all dimensions of this dataset. By default, dimensions are sorted alphabetically. Returns ------- result : DataFrame Dataset as a pandas DataFrame. rr)rrrrrrr$s zDataset.to_dataframezpd.Indexz!list[tuple[Hashable, np.ndarray]]r)rarraysrrc Csddlm}t|tjrNtjdd|jDdd}|j}t dd|j D}n t |j  dd }d }|j f}|D]F\}} t| j\} } tj| | d } ||| |d || d } || f||<qrdS)Nr)COOcSsg|]}t|qSrrr)rcoderrrrIsz;Dataset._set_sparse_data_from_dataframe..rcss|] }|jVqdSrrrlevrrrrKsz:Dataset._set_sparse_data_from_dataframe..rrTrF)Zhas_duplicatesrqr1)r6rrrrrrcodesZis_monotonic_increasingrrarangerrxrdtypes maybe_promoterr) rrrrrr-Z is_sortedrrrrr1rrrr_set_sparse_data_from_dataframeCs(   z'Dataset._set_sparse_data_from_dataframec Cst|tjs*|D]\}}||f||<qdStdd|jD}t|j}t||jdk}|D]N\}}|rt |j \} } t || | } nt ||j } || |<|| f||<q`dS)Ncss|] }|jVqdSrrrrrrrosz9Dataset._set_numpy_data_from_dataframe..r)rrrrrrrrrrrrrfullr) rrrrrrrindexerZmissing_valuesrr1rrrr_set_numpy_data_from_dataframecs    z&Dataset._set_numpy_data_from_dataframe)r5 dataframer6rc Cs |jjstdt|j}t|tjr4|js4tddd|D}i}i}t|tjrt ddt |j D}t ||j D](\}} t| |} | ||<|| q~n:|jdk r|jnd} | f}t|| } | || <|| |j|t||d } |r| |||n| |||| S) aUConvert a pandas.DataFrame into an xarray.Dataset Each column will be converted into an independent variable in the Dataset. If the dataframe's index is a MultiIndex, it will be expanded into a tensor product of one-dimensional indices (filling in missing values with NaN). This method will produce a Dataset very similar to that on which the 'to_dataframe' method was called, except with possibly redundant dimensions (since all dataset variables will have the same dimensionality) Parameters ---------- dataframe : DataFrame DataFrame from which to copy data and indices. sparse : bool, default: False If true, create a sparse arrays instead of dense numpy arrays. This can potentially save a large amount of memory if the DataFrame has a MultiIndex. Requires the sparse package (sparse.pydata.org). Returns ------- New Dataset. See Also -------- xarray.DataArray.from_series pandas.DataFrame.to_xarray z0cannot convert DataFrame with non-unique columnszCcannot convert a DataFrame with a non-unique MultiIndex into xarraycSsg|]\}}|t|fqSrrrDrrrrsz*Dataset.from_dataframe..css&|]\}}|dk r|nd|VqdS)Nzlevel_%ir)rr@rrrrrsz)Dataset.from_dataframe..Nrr)rZ is_uniquerr7rrrrrBr enumeraterrrr1rrNrrgrrr) r5rr6rrr3rrrrZxr_idxZ index_namerrrrfrom_dataframes8$    zDataset.from_dataframe DaskDataFrame)rrvrc s:ddlm}ddlm}j|d}t|}|fddjD|jg}|D]}zj |} Wn<t k rj |} |j | | t jd} t|f| } YnXt| tr| } | |jj} |j| d|gd} || qZ|j|d d }|r6|}t|d kr,|\}||}n ||}|S) ap Convert this dataset into a dask.dataframe.DataFrame. The dimensions, coordinates and data variables in this dataset form the columns of the DataFrame. Parameters ---------- dim_order : list, optional Hierarchical dimension order for the resulting dataframe. All arrays are transposed to this order and then written out as flat vectors in contiguous order, so the last dimension in this list will be contiguous in the resulting DataFrame. This has a major influence on which operations are efficient on the resulting dask dataframe. If provided, must include all dimensions of this dataset. By default, dimensions are sorted alphabetically. set_index : bool, default: False If set_index=True, the dask DataFrame is indexed by this dataset's coordinate. Since dask DataFrames do not support multi-indexes, set_index only works if the dataset only contains one dimension. Returns ------- dask.dataframe.DataFrame rNrc3s|]}|jkr|VqdSrr>rr rrrs z,Dataset.to_dask_dataframe..)rrr)rrr)rrdask.dataframerrrextendr-r,rrrrrrrSrrRrrsrrrZ from_arrayrrrrrv)rrrvrddrrZ series_listrrrrZ dask_arrayZseriesZdfrrr rto_dask_dataframes6         zDataset.to_dask_dataframe)rrrcCsit|jt|jid}|jD]&}|d|||jj||diq |jD]&}|d|||jj||diqN|rt|j |d<|S)aZ Convert this dataset to a dictionary following xarray naming conventions. Converts all variables and attributes to native Python objects Useful for converting to json. To avoid datetime incompatibility use decode_times=False kwarg in xarrray.open_dataset. Parameters ---------- data : bool, default: True Whether to include the actual data in the dictionary. When set to False, returns just the schema. encoding : bool, default: False Whether to include the Dataset's encoding in the dictionary. Returns ------- d : dict Dict with keys: "coords", "attrs", "dims", "data_vars" and optionally "encoding". See Also -------- Dataset.from_dict DataArray.to_dict )r-r.rr,r-)rrr,r) rKr.rrr-rrto_dictr,r)rrrrFrrrrr  s   zDataset.to_dict)r5rFrc Csddht|s|}n,ddl}||di|di}zdd|D}Wn<tk r}ztdjt |j ddW5d}~XYnX||}t|dit|d i}| |}|j |d i|j |d i|S) aConvert a dictionary into an xarray.Dataset. Parameters ---------- d : dict-like Mapping with a minimum structure of ``{"var_0": {"dims": [..], "data": [..]}, ...}`` Returns ------- obj : Dataset See also -------- Dataset.to_dict DataArray.from_dict Examples -------- >>> d = { ... "t": {"dims": ("t"), "data": [0, 1, 2]}, ... "a": {"dims": ("t"), "data": ["a", "b", "c"]}, ... "b": {"dims": ("t"), "data": [10, 20, 30]}, ... } >>> ds = xr.Dataset.from_dict(d) >>> ds Dimensions: (t: 3) Coordinates: * t (t) int64 0 1 2 Data variables: a (t) >> d = { ... "coords": { ... "t": {"dims": "t", "data": [0, 1, 2], "attrs": {"units": "s"}} ... }, ... "attrs": {"title": "air temperature"}, ... "dims": "t", ... "data_vars": { ... "a": {"dims": "t", "data": [10, 20, 30]}, ... "b": {"dims": "t", "data": ["a", "b", "c"]}, ... }, ... } >>> ds = xr.Dataset.from_dict(d) >>> ds Dimensions: (t: 3) Coordinates: * t (t) int64 0 1 2 Data variables: a (t) int64 10 20 30 b (t) .z1cannot convert dict without the key '{dims_data}')Z dims_datarr.r)issubsetrrBrchainrrrrrrrr.rr)r5rFrrZ variable_dictrrr-rrr from_dictNs.?     zDataset.from_dictc Osi}|dd}|dkr"tdd}|jD]@\}}||jkrH|||<q,||f||||<|r,|j||_q,|rx|jnd}|j||dS)NrTrr6)rrAr rBrr%r.r~) rfrrFrrrrAr.rrr _unary_ops    zDataset._unary_opc sddlm}ddlm}t||r&tS|dkr6tdn|}t||tfr\t|||dd\}}|sdn fdd}|j |||d } | S) Nrr^GroupByZarithmetic_joinFrcs ||Srrrrrrz$Dataset._binary_op..)r) rr_xarray.core.groupbyrrNotImplementedr@rr%_calculate_binary_op) rrrZ reflexiverr_rZ align_typegrSrrr _binary_ops   zDataset._binary_opcCsddlm}ddlm}t||r*tdt||tfrF|j|dd}t |}|j ||dd}|j |j |j |j|jdd |S) Nrr^rzLin-place operations between a Dataset and a grouped object are not permittedFrTr|)r.r3rz)rr_rrrr rr9r Zinplace_to_noninplace_oprr~r rr%r*)rrrr_rrrSrrr_inplace_binary_ops$    zDataset._inplace_binary_opinner)rzrc sfdd}t|rBt|tsB|j|j|}t|St|dd}j|}t|tr||j|jj |j } n$t|d|fddjD} |j | t |j |_ |S)Ncsr0t|t|kr0tdt|dt|i}|D]@}||kr\||||||<q8dkr8||tj||<q8|D](}||kr~dkr~||tj||<q~|S)NzOdatasets must have the same data variables for in-place arithmetic operations: r)leftr-)rightr-)rrrrnan)Z lhs_data_varsZ rhs_data_varsZlhs_varsZrhs_varsZ dest_varsr)rrzrrrapply_over_bothsz5Dataset._calculate_binary_op..apply_over_bothr-rcsi|]}|j|qSrrr)rother_variablerrrrsz0Dataset._calculate_binary_op..)r!rOrrr,rJrr-rQrr rrVr') rrrrrzr"Z new_data_varsZ other_coordsrSZnew_varsr)rrzrr#rrrs.       zDataset._calculate_binary_opcCs6|j|_|jD]"}||jkr|j|j|j|_qdSr)r.r)rrrArrrr s  zDataset._copy_attrs_fromrupperzLiteral[('upper', 'lower')])rrr@labelrc Cs|dkr |S|dkr"td||tddi}|tddi}|dkrL|}n|dkrZ|}ntdt|j|\}}i} |jD]d\} } | |kr|| | | <q|| jkr| |jkr| || || | <q| || | <q| | | <q|j | |d } |dkr| ||dS| SdS) a"Calculate the n-th order discrete difference along given axis. Parameters ---------- dim : Hashable Dimension over which to calculate the finite difference. n : int, default: 1 The number of times values are differenced. label : {"upper", "lower"}, default: "upper" The new coordinate in dimension ``dim`` will have the values of either the minuend's or subtrahend's coordinate for values 'upper' and 'lower', respectively. Returns ------- difference : Dataset The n-th order finite difference of this object. Notes ----- `n` matches numpy's behavior and is different from pandas' first argument named `periods`. Examples -------- >>> ds = xr.Dataset({"foo": ("x", [5, 5, 6, 6])}) >>> ds.diff("x") Dimensions: (x: 3) Dimensions without coordinates: x Data variables: foo (x) int64 0 1 0 >>> ds.diff("x", 2) Dimensions: (x: 2) Dimensions without coordinates: x Data variables: foo (x) int64 1 -1 See Also -------- Dataset.differentiate rz'order `n` must be non-negative but got Nrrr$lowerz8The 'label' argument has to be either 'upper' or 'lower'r) rrr6rrrBrr,rr~diff) rrr@r%Z slice_startZ slice_endZ slice_newr3rrrrrrrrr's21    z Dataset.diffzMapping[Any, int] | None)rshiftsr1 shifts_kwargsrc  st||d}fdd|D}|r2td|di}jD]`\}|jkrt|trj||tj n|}fdd|D}j ||d||<q@||<q@ |S) aShift this dataset by an offset along one or more dimensions. Only data variables are moved; coordinates stay in place. This is consistent with the behavior of ``shift`` in pandas. Values shifted from beyond array bounds will appear at one end of each dimension, which are filled according to `fill_value`. For periodic offsets instead see `roll`. Parameters ---------- shifts : mapping of hashable to int 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 or dict-like, optional Value to use for newly missing values. If a dict-like, maps variable names (including coordinates) to fill values. **shifts_kwargs The keyword arguments form of ``shifts``. One of shifts or shifts_kwargs must be provided. Returns ------- shifted : Dataset Dataset with the same coordinates and attributes but shifted data variables. See Also -------- roll Examples -------- >>> ds = xr.Dataset({"foo": ("x", list("abcde"))}) >>> ds.shift(x=2) Dimensions: (x: 5) Dimensions without coordinates: x Data variables: foo (x) object nan nan 'a' 'b' 'c' shiftcsg|]}|jkr|qSrr>rr rrrs z!Dataset.shift.. dimensions do not existcs i|]\}}|jkr||qSrr>rDrrrrs z!Dataset.shift..)r1r() rMrrrBr,rrrrNAr*r{) rr(r1r)invalidrrrZ var_shiftsrrrrr*fs1   z Dataset.shift)rr( roll_coordsr)rc  st||d}fdd|D}|r2td|d|rLtj|\}}d}n tj}tjj}tj}i}j D]R\} | |kr|| || <qz| |krĈj fdd| Dd || <qz|| <qzj ||d S) aRoll this dataset by an offset along one or more dimensions. Unlike shift, roll treats the given dimensions as periodic, so will not create any missing values to be filled. Also unlike shift, roll may rotate all variables, including coordinates if specified. The direction of rotation is consistent with :py:func:`numpy.roll`. Parameters ---------- shifts : mapping of hashable to int, optional A dict with keys matching dimensions and values given by integers to rotate each of the given dimensions. Positive offsets roll to the right; negative offsets roll to the left. roll_coords : bool, default: False Indicates whether to roll the coordinates by the offset too. **shifts_kwargs : {dim: offset, ...}, optional The keyword arguments form of ``shifts``. One of shifts or shifts_kwargs must be provided. Returns ------- rolled : Dataset Dataset with the same attributes but rolled data and coordinates. See Also -------- shift Examples -------- >>> ds = xr.Dataset({"foo": ("x", list("abcde"))}, coords={"x": np.arange(5)}) >>> ds.roll(x=2) Dimensions: (x: 5) Coordinates: * x (x) int64 0 1 2 3 4 Data variables: foo (x) >> ds.roll(x=2, roll_coords=True) Dimensions: (x: 5) Coordinates: * x (x) int64 3 4 0 1 2 Data variables: foo (x) rr rrrs z Dataset.roll..r+r,rcs i|]\}}|jkr||qSrr>)rrsrrrrs z Dataset.roll..)r(r) rMrr8rrr*rrr-rBr1r{) rr(r0r)r.r3rZ unrolled_varsrrrr/rr1s(8      z Dataset.rollz1Hashable | DataArray | list[Hashable | DataArray])rr ascendingrc sddlmt|ts|g}n|}fdd|D}tf|ddi}|d}|dd}tt}|D],}|jdkrtd |j\} ||  |qji} | D]4\} }t t t|} |r| n | ddd | | <q|| S) a Sort object by labels or values (along an axis). Sorts the dataset, either along specified dimensions, or according to values of 1-D dataarrays that share dimension with calling object. If the input variables are dataarrays, then the dataarrays are aligned (via left-join) to the calling object prior to sorting by cell values. NaNs are sorted to the end, following Numpy convention. If multiple sorts along the same dimension is given, numpy's lexsort is performed along that dimension: https://numpy.org/doc/stable/reference/generated/numpy.lexsort.html and the FIRST key in the sequence is used as the primary sort key, followed by the 2nd key, etc. Parameters ---------- variables : Hashable, DataArray, or list of hashable or DataArray 1D DataArray objects or name(s) of 1D variable(s) in coords/data_vars whose values are used to sort the dataset. ascending : bool, default: True Whether to sort by ascending or descending order. Returns ------- sorted : Dataset A new dataset where all the specified dims are sorted by dim labels. See Also -------- DataArray.sortby numpy.sort pandas.sort_values pandas.sort_index Examples -------- >>> ds = xr.Dataset( ... { ... "A": (("x", "y"), [[1, 2], [3, 4]]), ... "B": (("x", "y"), [[5, 6], [7, 8]]), ... }, ... coords={"x": ["b", "a"], "y": [1, 0]}, ... ) >>> ds = ds.sortby("x") >>> ds Dimensions: (x: 2, y: 2) Coordinates: * x (x) .rrrNzInput DataArray is not 1-D.r)rr_rrr%rrrrrrBrZlexsortrreversedr) rrr3rZ aligned_varsZ aligned_selfZaligned_other_varsZ vars_by_dimrrindicesrrr4rrLs&?    zDataset.sortbyrXrDzQuantileMethods | None) rqrrrrskipna interpolationrcs|dk r(tdt|dkr$td|}t|tr:|hn$|dksJ|dkrVtjnt|tt fddDdt j |t j d }ij D]x\}} fd d | jD} | s| js|jkr|rt | jt js| jt jkr| j|| |||d |<q| |<qfd djD} fddjD} |dkrRtdd}|r^jnd} j| | | d}|j|dS)aCompute the qth quantile of the data along the specified dimension. Returns the qth quantiles(s) of the array elements for each variable in the Dataset. Parameters ---------- q : float or array-like of float Quantile to compute, which must be between 0 and 1 inclusive. dim : str or Iterable of Hashable, 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 dataset'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. numeric_only : bool, optional If True, only apply ``func`` to variables with a numeric dtype. 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 : Dataset If `q` is a single quantile, then the result is a scalar for each variable in data_vars. If multiple percentiles are given, first axis of the result corresponds to the quantile and a quantile dimension is added to the return Dataset. The other dimensions are the dimensions that remain after the reduction of the array. See Also -------- numpy.nanquantile, numpy.quantile, pandas.Series.quantile, DataArray.quantile Examples -------- >>> ds = xr.Dataset( ... {"a": (("x", "y"), [[0.7, 4.2, 9.4, 1.5], [6.5, 7.3, 2.6, 1.9]])}, ... coords={"x": [7, 9], "y": [1, 1.5, 2, 2.5]}, ... ) >>> ds.quantile(0) # or ds.quantile(0, dim=...) Dimensions: () Coordinates: quantile float64 0.0 Data variables: a float64 0.7 >>> ds.quantile(0, dim="x") Dimensions: (y: 4) Coordinates: * y (y) float64 1.0 1.5 2.0 2.5 quantile float64 0.0 Data variables: a (y) float64 0.7 4.2 2.6 1.5 >>> ds.quantile([0, 0.5, 1]) Dimensions: (quantile: 3) Coordinates: * quantile (quantile) float64 0.0 0.5 1.0 Data variables: a (quantile) float64 0.7 3.4 9.4 >>> ds.quantile([0, 0.5, 1], dim="x") Dimensions: (quantile: 3, y: 4) Coordinates: * y (y) float64 1.0 1.5 2.0 2.5 * quantile (quantile) float64 0.0 0.5 1.0 Data variables: a (quantile, y) float64 0.7 4.2 2.6 1.5 3.6 ... 1.7 6.5 7.3 9.4 1.9 References ---------- .. [1] R. J. Hyndman and Y. Fan, "Sample quantiles in statistical packages," The American Statistician, 50(4), pp. 361-365, 1996 NzAThe `interpolation` argument to quantile was renamed to `method`.r=z.Cannot pass interpolation and method keywords!.c3s|]}|jkr|VqdSrr>rEr rrrs z#Dataset.quantile..z+Dataset does not contain the dimensions: %srcsg|]}|kr|qSrrrEr>rrrsz$Dataset.quantile..)rrrr8csh|]}|kr|qSrrrrrrrisz#Dataset.quantile..csi|]\}}|kr||qSrrrDrrrrsz$Dataset.quantile..Frr)quantile)rrrr rrrrrrrrfloat64rrBr-rrrrr:r*rAr.r~r)rr7rrrrr8r9rrrr2r3r.rurrrr:Vsby        zDataset.quantile)rrpctrrc Cstdstd||jkr(td|i}|jD]8\}}||jkrf||jkrn|j||d||<q6|||<q6t|j }|dkrt dd}|r|j nd}|j |||dS) 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 is True, computes percentage ranks. NaNs in the input array are returned as NaNs. The `bottleneck` library is required. Parameters ---------- dim : Hashable Dimension over which to compute rank. pct : bool, default: False If True, compute percentage ranks, otherwise compute integer ranks. keep_attrs : bool or None, optional If True, the dataset's attributes (`attrs`) will be copied from the original object to the new one. If False, the new object will be returned without attributes. Returns ------- ranked : Dataset Variables that do not depend on `dim` are dropped. Zuse_bottleneckz`rank requires bottleneck to be enabled. Call `xr.set_options(use_bottleneck=True)` to enable it.z(Dataset does not contain the dimension: )r<NFrr6) r@rrrrrBr,rankrr-rAr.r{) rrr<rrrrr2r.rrrr= s"!      z Dataset.rankzLiteral[(1, 2)]zDatetimeUnitOptions | None)rcoord edge_order datetime_unitrc Cs<ddlm}||jkr0||jkr0td|d||j}|jdkrVtd||j|jd}t|r|j j dkr|dkrt d t |j d}n |dkrd }|j|d }i}|jD]v\}} ||jkr(|| jkr(||jkr(t| r| j|d } tj| j|j|| |d } || j| ||<q| ||<q||S) a* Differentiate with the second order accurate central differences. .. note:: This feature is limited to simple cartesian geometry, i.e. coord must be one dimensional. Parameters ---------- coord : Hashable The coordinate to be used to compute the gradient. edge_order : {1, 2}, default: 1 N-th order accurate differences at the boundaries. datetime_unit : None or {"Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps", "fs", "as", None}, default: None Unit to compute gradient. Only valid for datetime coordinate. Returns ------- differentiated: Dataset See also -------- numpy.gradient: corresponding numpy function rrS Coordinate  does not exist.r9Coordinate {} must be 1 dimensional but is {} dimensionalmMNrlr2r@)r?rj)xarray.core.variablerSrrrrrrr(rrrr datetime_dataZ _to_numericrBr,r-rZgradientr get_axis_numr{) rr>r?r@rS coord_varrrrrAZgradrrr differentiateAsF     $  zDataset.differentiaterl)rr>r@rcCs4t|ttfs|f}|}|D]}|j||d}q|S)aIntegrate along the given coordinate using the trapezoidal rule. .. note:: This feature is limited to simple cartesian geometry, i.e. coord must be one dimensional. Parameters ---------- coord : hashable, or sequence of hashable Coordinate(s) used for the integration. datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', 'as', None}, optional Specify the unit if datetime coordinate is used. Returns ------- integrated : Dataset See also -------- DataArray.integrate numpy.trapz : corresponding numpy function Examples -------- >>> ds = xr.Dataset( ... data_vars={"a": ("x", [5, 5, 6, 6]), "b": ("x", [1, 2, 1, 0])}, ... coords={"x": [0, 1, 2, 3], "y": ("x", [1, 7, 3, 5])}, ... ) >>> ds Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 y (x) int64 1 7 3 5 Data variables: a (x) int64 5 5 6 6 b (x) int64 1 2 1 0 >>> ds.integrate("x") Dimensions: () Data variables: a float64 16.5 b float64 3.5 >>> ds.integrate("y") Dimensions: () Data variables: a float64 20.0 b float64 4.0 rFrrr_integrate_onerr>r@rrtrrr integrates 8zDataset.integratecsddlm}||jkr0||jkr0td|d||j}|jdkrVtd||j|jd}t|r|j j dkr|dkrt |j \}}n |dkrd}|j t|j|d d }it}|jD]\} } | |jkr|| jks|r| | <|| q| |jkr|| jkrt| r&t| |d } |rNtj| j|j| |d } | j} n.tj| j|j| |d } t| j} | ||| | | <q| | <qćfd d |jD} |j|| dS)NrrArBrCrrDrEr2rFrrcsi|]\}}|kr||qSrrrDrrrrsz*Dataset._integrate_one..rp)rGrSrrrrrrr(rrrrHr{r.rrrBr-rr,rZcumulative_trapezoidrIZtrapzrrr*r~)rr>r@ cumulativerSrJrr4r2rrAZintegZv_dimsr3rrrrMsh            zDataset._integrate_onecCs6t|ttfs|f}|}|D]}|j||dd}q|S)aIntegrate along the given coordinate using the trapezoidal rule. .. note:: This feature is limited to simple cartesian geometry, i.e. coord must be one dimensional. The first entry of the cumulative integral of each variable is always 0, in order to keep the length of the dimension unchanged between input and output. Parameters ---------- coord : hashable, or sequence of hashable Coordinate(s) used for the integration. datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', 'ps', 'fs', 'as', None}, optional Specify the unit if datetime coordinate is used. Returns ------- integrated : Dataset See also -------- DataArray.cumulative_integrate scipy.integrate.cumulative_trapezoid : corresponding scipy function Examples -------- >>> ds = xr.Dataset( ... data_vars={"a": ("x", [5, 5, 6, 6]), "b": ("x", [1, 2, 1, 0])}, ... coords={"x": [0, 1, 2, 3], "y": ("x", [1, 7, 3, 5])}, ... ) >>> ds Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 y (x) int64 1 7 3 5 Data variables: a (x) int64 5 5 6 6 b (x) int64 1 2 1 0 >>> ds.cumulative_integrate("x") Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 y (x) int64 1 7 3 5 Data variables: a (x) float64 0.0 5.0 10.5 16.5 b (x) float64 0.0 1.5 3.0 3.5 >>> ds.cumulative_integrate("y") Dimensions: (x: 4) Coordinates: * x (x) int64 0 1 2 3 y (x) int64 1 7 3 5 Data variables: a (x) float64 0.0 30.0 8.0 20.0 b (x) float64 0.0 9.0 3.0 4.0 T)r@rPrLrNrrrcumulative_integratesBzDataset.cumulative_integratecCs|jddddS)zt The real part of each data variable. See Also -------- numpy.ndarray.real cSs|jSr)realrrrrrNrzDataset.real..Trrr rrrrREs z Dataset.realcCs|jddddS)zy The imaginary part of each data variable. See Also -------- numpy.ndarray.imag cSs|jSr)imagrSrrrrYrzDataset.imag..TrTrUr rrrrVPs z Dataset.imagc Kszg}|jD]b\}}d}|D]:\}}|j|}t|rF||sN||krTd}q"d}q^q"|dkr||q||S)a Returns a ``Dataset`` with variables that match specific conditions. Can pass in ``key=value`` or ``key=callable``. A Dataset is returned containing only the variables for which all the filter tests pass. These tests are either ``key=value`` for which the attribute ``key`` has the exact value ``value`` or the callable passed into ``key=callable`` returns True. The callable will be passed a single value, either the value of the attribute ``key`` or ``None`` if the DataArray does not have an attribute with the name ``key``. Parameters ---------- **kwargs key : str Attribute name. value : callable or obj If value is a callable, it should return a boolean in the form of bool = func(attr) where attr is da.attrs[key]. Otherwise, value will be compared to the each DataArray's attrs[key]. Returns ------- new : Dataset New dataset with variables filtered by attribute. Examples -------- >>> temp = 15 + 8 * np.random.randn(2, 2, 3) >>> precip = 10 * np.random.rand(2, 2, 3) >>> lon = [[-99.83, -99.32], [-99.79, -99.23]] >>> lat = [[42.25, 42.21], [42.63, 42.59]] >>> dims = ["x", "y", "time"] >>> temp_attr = dict(standard_name="air_potential_temperature") >>> precip_attr = dict(standard_name="convective_precipitation_flux") >>> ds = xr.Dataset( ... dict( ... temperature=(dims, temp, temp_attr), ... precipitation=(dims, precip, precip_attr), ... ), ... coords=dict( ... lon=(["x", "y"], lon), ... lat=(["x", "y"], lat), ... time=pd.date_range("2014-09-06", periods=3), ... reference_time=pd.Timestamp("2014-09-05"), ... ), ... ) Get variables matching a specific standard_name: >>> ds.filter_by_attrs(standard_name="convective_precipitation_flux") Dimensions: (x: 2, y: 2, time: 3) Coordinates: lon (x, y) float64 -99.83 -99.32 -99.79 -99.23 lat (x, y) float64 42.25 42.21 42.63 42.59 * time (time) datetime64[ns] 2014-09-06 2014-09-07 2014-09-08 reference_time datetime64[ns] 2014-09-05 Dimensions without coordinates: x, y Data variables: precipitation (x, y, time) float64 5.68 9.256 0.7104 ... 7.992 4.615 7.805 Get all variables that have a standard_name attribute: >>> standard_name = lambda v: v is not None >>> ds.filter_by_attrs(standard_name=standard_name) Dimensions: (x: 2, y: 2, time: 3) Coordinates: lon (x, y) float64 -99.83 -99.32 -99.79 -99.23 lat (x, y) float64 42.25 42.21 42.63 42.59 * time (time) datetime64[ns] 2014-09-06 2014-09-07 2014-09-08 reference_time datetime64[ns] 2014-09-05 Dimensions without coordinates: x, y Data variables: temperature (x, y, time) float64 29.11 18.2 22.83 ... 18.28 16.15 26.63 precipitation (x, y, time) float64 5.68 9.256 0.7104 ... 7.992 4.615 7.805 FT)rrBr.rcallabler) rrFZ selectionrrZhas_value_flag attr_namepattern attr_valuerrrfilter_by_attrs]sQ  zDataset.filter_by_attrscCs t|dS)zUnify chunk size along all chunked dimensions of this Dataset. Returns ------- Dataset with consistent chunk sizes for all dask-array variables See Also -------- dask.array.core.unify_chunks rr*r rrrr+s zDataset.unify_chunkszCallable[..., T_Xarray]z Sequence[Any]zDataArray | Dataset | Nonerx)rrrFtemplatercCsddlm}||||||S)aw Apply a function to each block of this Dataset. .. warning:: This method is experimental and its signature may change. Parameters ---------- func : callable User-provided function that accepts a Dataset as its first parameter. The function will receive a subset or 'block' of this Dataset (see below), corresponding to one chunk along each chunked dimension. ``func`` will be executed as ``func(subset_dataset, *subset_args, **kwargs)``. This function must return either a single DataArray or a single Dataset. This function cannot add a new chunked dimension. args : sequence Passed to func after unpacking and subsetting any xarray objects by blocks. xarray objects in args must be aligned with obj, otherwise an error is raised. kwargs : Mapping or None Passed verbatim to func after unpacking. xarray objects, if any, will not be subset to blocks. Passing dask collections in kwargs is not allowed. template : DataArray, Dataset or None, optional xarray object representing the final result after compute is called. If not provided, the function will be first run on mocked-up data, that looks like this object but has sizes 0, to determine properties of the returned object such as dtype, variable names, attributes, new dimensions and new indexes (if any). ``template`` must be provided if the function changes the size of existing dimensions. When provided, ``attrs`` on variables in `template` are copied over to the result. Any ``attrs`` set by ``func`` will be ignored. Returns ------- A single DataArray or Dataset with dask backend, reassembled from the outputs of the function. Notes ----- This function is designed for when ``func`` needs to manipulate a whole xarray object subset to each block. Each block is loaded into memory. In the more common case where ``func`` can work on numpy arrays, it is recommended to use ``apply_ufunc``. If none of the variables in this object is backed by dask arrays, calling this function is equivalent to calling ``func(obj, *args, **kwargs)``. See Also -------- dask.array.map_blocks, xarray.apply_ufunc, xarray.Dataset.map_blocks xarray.DataArray.map_blocks Examples -------- Calculate an anomaly from climatology using ``.groupby()``. Using ``xr.map_blocks()`` allows for parallel operations with knowledge of ``xarray``, its indices, and its methods like ``.groupby()``. >>> def calculate_anomaly(da, groupby_type="time.month"): ... gb = da.groupby(groupby_type) ... clim = gb.mean(dim="time") ... return gb - clim ... >>> time = xr.cftime_range("1990-01", "1992-01", freq="M") >>> month = xr.DataArray(time.month, coords={"time": time}, dims=["time"]) >>> np.random.seed(123) >>> array = xr.DataArray( ... np.random.rand(len(time)), ... dims=["time"], ... coords={"time": time, "month": month}, ... ).chunk() >>> ds = xr.Dataset({"a": array}) >>> ds.map_blocks(calculate_anomaly, template=ds).compute() Dimensions: (time: 24) Coordinates: * time (time) object 1990-01-31 00:00:00 ... 1991-12-31 00:00:00 month (time) int64 1 2 3 4 5 6 7 8 9 10 11 12 1 2 3 4 5 6 7 8 9 10 11 12 Data variables: a (time) float64 0.1289 0.1132 -0.0856 ... 0.2287 0.1906 -0.05901 Note that one must explicitly use ``args=[]`` and ``kwargs={}`` to pass arguments to the function being applied in ``xr.map_blocks()``: >>> ds.map_blocks( ... calculate_anomaly, ... kwargs={"groupby_type": "time.year"}, ... template=ds, ... ) Dimensions: (time: 24) Coordinates: * time (time) object 1990-01-31 00:00:00 ... 1991-12-31 00:00:00 month (time) int64 dask.array Data variables: a (time) float64 dask.array r) map_blocks)Zxarray.core.parallelr])rrrrFr\r]rrrr]sg zDataset.map_blocksz float | NonezHashable | Anyzbool | Literal['unscaled']) rrdegr8rcondrrcovrc s$ddlm}i} |} t|dd} |jd} t|d} t| | }|dkrl| jdtj | j j }|dk rt |t r|j|}t|}|jdkrtd|jd|jdkrtd d ||ddtjf9}t||jdd }||}t|jd }tj|}|rx||| d d}|| |j<tjj|dd}|||f|t|dddi| dd}|| |j<|jD]\}}|jkrqt|jr|| ks|s|dkrd} n|dkrt t!|"} fdd|jD}i}|rHt|d}|j#f|$||i}|||i}|ddtjf}n|}|}|dk rp||ddtjf9}t%&B|rt%'dtj(nt%'dtj(t)j*||j|| d\}}W5QRXt |t+r|d}nd}||||gt,|-|t| dddi||dd}|r*|.|}|| |j<|sD|dkr||rP|n|/t,|-||dd}|r~|.|}|| |j<|rtj0t1|j2|}|t3||}|dkrd}n*| jd| krt4d|| jd| }||dd |}|| |d!<qt5|| |j67d"S)#a) Least squares polynomial fit. This replicates the behaviour of `numpy.polyfit` but differs by skipping invalid values when `skipna = True`. Parameters ---------- dim : hashable Coordinate along which to fit the polynomials. deg : int Degree of the fitting polynomial. skipna : bool or None, optional If True, removes all invalid values before fitting each 1D slices of the array. Default is True if data is stored in a dask.array or if there is any invalid values, False otherwise. rcond : float or None, optional Relative condition number to the fit. w : hashable or Any, optional Weights to apply to the y-coordinate of the sample points. Can be an array-like object or the name of a coordinate in the dataset. full : bool, default: False Whether to return the residuals, matrix rank and singular values in addition to the coefficients. cov : bool or "unscaled", default: False Whether to return to the covariance matrix in addition to the coefficients. The matrix is not scaled if `cov='unscaled'`. Returns ------- polyfit_results : Dataset A single dataset which contains (for each "var" in the input dataset): [var]_polyfit_coefficients The coefficients of the best fit for each variable in this dataset. [var]_polyfit_residuals The residuals of the least-square computation for each variable (only included if `full=True`) When the matrix rank is deficient, np.nan is returned. [dim]_matrix_rank The effective rank of the scaled Vandermonde coefficient matrix (only included if `full=True`) The rank is computed ignoring the NaN values that might be skipped. [dim]_singular_values The singular values of the scaled Vandermonde coefficient matrix (only included if `full=True`) [var]_polyfit_covariance The covariance matrix of the polynomial coefficient estimates (only included if `full=False` and `cov=True`) Warns ----- RankWarning The rank of the coefficient matrix in the least-squares fit is deficient. The warning is not raised with in-memory (not dask) data and `full=True`. See Also -------- numpy.polyfit numpy.polyval xarray.polyval rr^F)strictr4rNz!Expected a 1-d array for weights.zExpected w and z to have the same lengthrZdegree matrix_rankr)Z compute_uvrZsingular_values)rr-rTcsg|]}|kr|qSrr)rZdimnamermrrrsz#Dataset.polyfit..ZstackedrOonce)r_r8Zpolyfit_coefficientsZpolyfit_residualsZunscaledzKThe number of data points must exceed order to scale the covariance matrix.)cov_icov_jr>Zpolyfit_covariance)r,r.)8rr_r?rrrZvanderrrZfinforZepsrrr-rrr ZnewaxissqrtrYr!Zget_temp_dimnamerZlinalgrbZsvdrr,rBrCrrrZisnullrrrcatch_warnings simplefilterZ RankWarningrZ least_squaresrrrprsqueezeinvdotTr-rrJr.rs) rrr^r8r_rrr`r_rZ skipna_darZxnamerlhsZscaleZ degree_dimr=Z_singZsingrrZ dims_to_stackZstacked_coordsZ stacked_dimrhsZscale_daZcoeffsZ residualsZVbaseZfacZ covariancerrmrpolyfit5sD                         zDataset.polyfitconstantz*Mapping[Any, int | tuple[int, int]] | Nonerrz>> ds = xr.Dataset({"foo": ("x", range(5))}) >>> ds.pad(x=(1, 2)) Dimensions: (x: 8) Dimensions without coordinates: x Data variables: foo (x) float64 nan 0.0 1.0 2.0 3.0 4.0 nan nan pad)ZedgeZreflectZ symmetricwrap)rsrtrurvrqNTrcs i|]\}}|jkr||qSrr>rDrrrrs zDataset.pad..)rrrrsrtrurvr)rrrrrw)r3r.)rMrArrrBrKZ get_all_dimsrr,rxrr1r~rNr%r~)rrrrrsrtrurvrrwZcoord_pad_modeZcoord_pad_optionsrrZpad_dimsr3rrrZ var_pad_widthZdim_varrrr.rrrrxs`          z Dataset.pad)rrr8r1rrc Cs|td||||dS)aK Return the coordinate label of the minimum value along a dimension. Returns a new `Dataset` named after the dimension with the values of the coordinate labels along that dimension corresponding to minimum values along that dimension. In comparison to :py:meth:`~Dataset.argmin`, this returns the coordinate label while :py:meth:`~Dataset.argmin` returns the index. Parameters ---------- dim : Hashable, optional Dimension over which to apply `idxmin`. This is optional for 1D variables, but required for variables with 2 or more dimensions. skipna : bool or None, optional If True, skip missing values (as marked by NaN). By default, only skips missing values for ``float``, ``complex``, and ``object`` dtypes; other dtypes either do not have a sentinel missing value (``int``) or ``skipna=True`` has not been implemented (``datetime64`` or ``timedelta64``). fill_value : Any, default: NaN Value to be filled in case all of the values along a dimension are null. By default this is NaN. The fill value and result are automatically converted to a compatible dtype if possible. Ignored if ``skipna`` is False. keep_attrs : bool or None, optional If True, the attributes (``attrs``) will be copied from the original object to the new one. If False, the new object will be returned without attributes. Returns ------- reduced : Dataset New `Dataset` object with `idxmin` applied to its data and the indicated dimension removed. See Also -------- DataArray.idxmin, Dataset.idxmax, Dataset.min, Dataset.argmin Examples -------- >>> array1 = xr.DataArray( ... [0, 2, 1, 0, -2], dims="x", coords={"x": ["a", "b", "c", "d", "e"]} ... ) >>> array2 = xr.DataArray( ... [ ... [2.0, 1.0, 2.0, 0.0, -2.0], ... [-4.0, np.NaN, 2.0, np.NaN, -2.0], ... [np.NaN, np.NaN, 1.0, np.NaN, np.NaN], ... ], ... dims=["y", "x"], ... coords={"y": [-1, 0, 1], "x": ["a", "b", "c", "d", "e"]}, ... ) >>> ds = xr.Dataset({"int": array1, "float": array2}) >>> ds.min(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int int64 -2 float (y) float64 -2.0 -4.0 1.0 >>> ds.argmin(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int int64 4 float (y) int64 4 0 2 >>> ds.idxmin(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int >> array1 = xr.DataArray( ... [0, 2, 1, 0, -2], dims="x", coords={"x": ["a", "b", "c", "d", "e"]} ... ) >>> array2 = xr.DataArray( ... [ ... [2.0, 1.0, 2.0, 0.0, -2.0], ... [-4.0, np.NaN, 2.0, np.NaN, -2.0], ... [np.NaN, np.NaN, 1.0, np.NaN, np.NaN], ... ], ... dims=["y", "x"], ... coords={"y": [-1, 0, 1], "x": ["a", "b", "c", "d", "e"]}, ... ) >>> ds = xr.Dataset({"int": array1, "float": array2}) >>> ds.max(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int int64 2 float (y) float64 2.0 2.0 1.0 >>> ds.argmax(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int int64 1 float (y) int64 0 2 2 >>> ds.idxmax(dim="x") Dimensions: (y: 3) Coordinates: * y (y) int64 -1 0 1 Data variables: int >> a = np.arange(0, 5, 1) >>> b = np.linspace(0, 1, 5) >>> ds = xr.Dataset({"a": ("x", a), "b": ("x", b)}) >>> ds Dimensions: (x: 5) Dimensions without coordinates: x Data variables: a (x) int64 0 1 2 3 4 b (x) float64 0.0 0.25 0.5 0.75 1.0 >>> ds.query(x="a > 2") Dimensions: (x: 2) Dimensions without coordinates: x Data variables: a (x) int64 3 4 b (x) float64 0.75 1.0 queryz expr for dim z# must be a string to be evaluated, z givenc s&i|]\}}|tj|gdqS))Z resolversrr)reval)rrexprrrrrrrD!sz!Dataset.query..r)rMrBrrrJrr) rrrrrrrrrrrrrr sO   z Dataset.queryz+str | DataArray | Iterable[str | DataArray]zCallable[..., Any]zdict[str, Any] | NonezSequence[str] | None) rr-rrr8rrrrFrc  sddlmddlm} ddlm} ddlm} m} |dkr@i}|dkrLi}|dkrXi}|sbgn$t |t svt |t s~|gnt |t |t st || st |t s|g}fdd|D} | D]fd dj D7qt tt tj tstd | | } fd d| D} t|\}}t||||\t||d fd d|D|dfdd|Dfdd|Dg fdd}t}jD]\}}|| krd}nt |d}| ||f| ddfddtt| dDdgddggdditjtjft|d\}}|||d<|||d <q||||d}j|_|S)!aM Curve fitting optimization for arbitrary functions. Wraps `scipy.optimize.curve_fit` with `apply_ufunc`. Parameters ---------- coords : hashable, DataArray, or sequence of hashable or DataArray Independent coordinate(s) over which to perform the curve fitting. Must share at least one dimension with the calling object. When fitting multi-dimensional functions, supply `coords` as a sequence in the same order as arguments in `func`. To fit along existing dimensions of the calling object, `coords` can also be specified as a str or sequence of strs. func : callable User specified function in the form `f(x, *params)` which returns a numpy array of length `len(x)`. `params` are the fittable parameters which are optimized by scipy curve_fit. `x` can also be specified as a sequence containing multiple coordinates, e.g. `f((x0, x1), *params)`. reduce_dims : str, Iterable of Hashable or None, optional Additional dimension(s) over which to aggregate while fitting. For example, calling `ds.curvefit(coords='time', reduce_dims=['lat', 'lon'], ...)` will aggregate all lat and lon points and fit the specified function along the time dimension. skipna : bool, default: True Whether to skip missing values when fitting. Default is True. p0 : dict-like, optional Optional dictionary of parameter names to initial guesses passed to the `curve_fit` `p0` arg. If none or only some parameters are passed, the rest will be assigned initial values following the default scipy behavior. bounds : dict-like, optional Optional dictionary of parameter names to bounding values passed to the `curve_fit` `bounds` arg. If none or only some parameters are passed, the rest will be unbounded following the default scipy behavior. param_names : sequence of hashable, optional Sequence of names for the fittable parameters of `func`. If not supplied, this will be automatically determined by arguments of `func`. `param_names` should be manually supplied when fitting a function that takes a variable number of parameters. **kwargs : optional Additional keyword arguments to passed to scipy curve_fit. Returns ------- curvefit_results : Dataset A single dataset which contains: [var]_curvefit_coefficients The coefficients of the best fit. [var]_curvefit_covariance The covariance matrix of the coefficient estimates. See Also -------- Dataset.polyfit scipy.optimize.curve_fit r) curve_fit) broadcast) apply_ufunc) _THIS_ARRAYr_Ncs"g|]}t|tr|n|qSr)rrrr>r rrr!sz$Dataset.curvefit..csg|]}|r|qSr)rrrt)r>rrrr!szNo arguments to `coords` were identified as a dimension on the calling object, and no dims were supplied to `reduce_dims`. This would result in fitting on scalar data.csg|]}|jdqS))r,)r.r)preserved_dimsrrrr!srcsg|] }|qSrrr)rrrr!srcsg|]}|dqSrrrrrrr!scsg|]}|dqSrrrrrrr!scstdd|D}|}rtjtjt|ddt|gdd}|dd|f}||}t|stgtj}tgtj}||fSt |}||f|\}}||fS)NcSsg|] }|qSr)ravelrrrrr!sz6Dataset.curvefit.._wrapper..rr) rZvstackrrMrisnanrrr!rj)Ycoords_rFrrrpoptpcov)rrn_paramsr8rr_wrapper!s, z"Dataset.curvefit.._wrapperrdr4TZ parallelizedcsg|]}qSrrrE) reduce_dims_rrr!srparamrerfZ output_sizes)rrerf)Z vectorizerSZinput_core_dimsZoutput_core_dimsZdask_gufunc_kwargsZ output_dtypesr2rFZcurvefit_coefficientsZcurvefit_covariance)Zscipy.optimizerrrxarray.core.computationrrrr_rrrrrrrrrr setdefaultrJr,rBrrr;rr.rs)rr-rrr8rrrrFrrrr_rrrrrrrrrr) rr>rrrrrrrr8rcurvefitL!sC              zDataset.curvefitfirstz!Literal[('first', 'last', False)])rrkeeprcs|t|tr|f}n&|dkr"j}nt|ts4|g}n|}t|tj}|r^td|dfdd|D}|S)aReturns a new Dataset with duplicate dimension values removed. Parameters ---------- dim : dimension label or labels Pass `...` to drop duplicates along all dimensions. keep : {"first", "last", False}, default: "first" Determines which duplicates (if any) to keep. - ``"first"`` : Drop duplicates except for the first occurrence. - ``"last"`` : Drop duplicates except for the last occurrence. - False : Drop all duplicates. Returns ------- Dataset See Also -------- DataArray.drop_duplicates .'z' not found in dimensionscs"i|]}||jdqS))r)rZ duplicatedrrrrrr("sz+Dataset.drop_duplicates..)rrrrrrr)rrrrrr3rrrdrop_duplicates"s  zDataset.drop_duplicatesrrgzLiteral[('date', 'year', None)]z Any | None)rcalendarralign_onrB use_cftimercCst||||||dS)aConvert the Dataset to another calendar. Only converts the individual timestamps, does not modify any data except in dropping invalid/surplus dates or inserting missing dates. If the source and target calendars are either no_leap, all_leap or a standard type, only the type of the time array is modified. When converting to a leap year from a non-leap year, the 29th of February is removed from the array. In the other direction the 29th of February will be missing in the output, unless `missing` is specified, in which case that value is inserted. For conversions involving `360_day` calendars, see Notes. This method is safe to use with sub-daily data as it doesn't touch the time part of the timestamps. Parameters --------- calendar : str The target calendar name. dim : Hashable, default: "time" Name of the time coordinate. align_on : {None, 'date', 'year'}, optional Must be specified when either source or target is a `360_day` calendar, ignored otherwise. See Notes. missing : Any or None, optional By default, i.e. if the value is None, this method will simply attempt to convert the dates in the source calendar to the same dates in the target calendar, and drop any of those that are not possible to represent. If a value is provided, a new time coordinate will be created in the target calendar with the same frequency as the original time coordinate; for any dates that are not present in the source, the data will be filled with this value. Note that using this mode requires that the source data have an inferable frequency; for more information see :py:func:`xarray.infer_freq`. For certain frequency, source, and target calendar combinations, this could result in many missing values, see notes. use_cftime : bool or None, optional Whether to use cftime objects in the output, only used if `calendar` is one of {"proleptic_gregorian", "gregorian" or "standard"}. If True, the new time axis uses cftime objects. If None (default), it uses :py:class:`numpy.datetime64` values if the date range permits it, and :py:class:`cftime.datetime` objects if not. If False, it uses :py:class:`numpy.datetime64` or fails. Returns ------- Dataset Copy of the dataarray with the time coordinate converted to the target calendar. If 'missing' was None (default), invalid dates in the new calendar are dropped, but missing dates are not inserted. If `missing` was given, the new data is reindexed to have a time axis with the same frequency as the source, but in the new calendar; any missing datapoints are filled with `missing`. Notes ----- Passing a value to `missing` is only usable if the source's time coordinate as an inferable frequencies (see :py:func:`~xarray.infer_freq`) and is only appropriate if the target coordinate, generated from this frequency, has dates equivalent to the source. It is usually **not** appropriate to use this mode with: - Period-end frequencies : 'A', 'Y', 'Q' or 'M', in opposition to 'AS' 'YS', 'QS' and 'MS' - Sub-monthly frequencies that do not divide a day evenly : 'W', 'nD' where `N != 1` or 'mH' where 24 % m != 0). If one of the source or target calendars is `"360_day"`, `align_on` must be specified and two options are offered. - "year" The dates are translated according to their relative position in the year, ignoring their original month and day information, meaning that the missing/surplus days are added/removed at regular intervals. From a `360_day` to a standard calendar, the output will be missing the following dates (day of year in parentheses): To a leap year: January 31st (31), March 31st (91), June 1st (153), July 31st (213), September 31st (275) and November 30th (335). To a non-leap year: February 6th (36), April 19th (109), July 2nd (183), September 12th (255), November 25th (329). From a standard calendar to a `"360_day"`, the following dates in the source array will be dropped: From a leap year: January 31st (31), April 1st (92), June 1st (153), August 1st (214), September 31st (275), December 1st (336) From a non-leap year: February 6th (37), April 20th (110), July 2nd (183), September 13th (256), November 25th (329) This option is best used on daily and subdaily data. - "date" The month/day information is conserved and invalid dates are dropped from the output. This means that when converting from a `"360_day"` to a standard calendar, all 31st (Jan, March, May, July, August, October and December) will be missing as there is no equivalent dates in the `"360_day"` calendar and the 29th (on non-leap years) and 30th of February will be dropped as there are no equivalent dates in a standard calendar. This option is best used with data on a frequency coarser than daily. )rrrBr)r)rrrrrBrrrrr+"srzDataset.convert_calendarz*pd.DatetimeIndex | CFTimeIndex | DataArray)rtargetrrcCst|||dS)aInterpolates the Dataset to another calendar based on decimal year measure. Each timestamp in `source` and `target` are first converted to their decimal year equivalent then `source` is interpolated on the target coordinate. The decimal year of a timestamp is its year plus its sub-year component converted to the fraction of its year. For example "2000-03-01 12:00" is 2000.1653 in a standard calendar or 2000.16301 in a `"noleap"` calendar. This method should only be used when the time (HH:MM:SS) information of time coordinate is not important. Parameters ---------- target: DataArray or DatetimeIndex or CFTimeIndex The target time coordinate of a valid dtype (np.datetime64 or cftime objects) dim : Hashable, default: "time" The time coordinate name. Return ------ DataArray The source interpolated on the decimal years of target, rm)r)rrrrrrr"szDataset.interp_calendarz$Hashable | DataArray | IndexVariablera)rrjrestore_coord_dimsrcCs6ddlm}t|ts&td|d|||||dS)aReturns a DatasetGroupBy object for performing grouped operations. Parameters ---------- group : Hashable, DataArray or IndexVariable Array whose unique values should be used to group this array. If a string, must be the name of a variable contained in this dataset. squeeze : bool, default: True If "group" is a dimension of any arrays in this dataset, `squeeze` controls whether the subarrays have a dimension of length 1 along that dimension or if the dimension is squeezed out. restore_coord_dims : bool, default: False If True, also restore the dimension order of multi-dimensional coordinates. Returns ------- grouped : DatasetGroupBy A `DatasetGroupBy` object patterned after `pandas.GroupBy` that can be iterated over in the form of `(unique_value, grouped_array)` pairs. See Also -------- Dataset.groupby_bins DataArray.groupby core.groupby.DatasetGroupBy pandas.DataFrame.groupby Dataset.resample DataArray.resample rr`z%`squeeze` must be True or False, but z was supplied)rjr)rrarrr )rrrjrrarrrgroupby"s$   zDataset.groupbyr`zArrayLike | None) rbinsr r precisioninclude_lowestrjrrc Cs*ddlm} | |||||||||ddS)a6 Returns a DatasetGroupBy object for performing grouped operations. Rather than using all unique values of `group`, the values are discretized first by applying `pandas.cut` [1]_ to `group`. Parameters ---------- group : Hashable, DataArray or IndexVariable Array whose binned values should be used to group this array. If a string, must be the name of a variable contained in this dataset. bins : int or array-like If bins is an int, it defines the number of equal-width bins in the range of x. However, in this case, the range of x is extended by .1% on each side to include the min or max values of x. If bins is a sequence it defines the bin edges allowing for non-uniform bin width. No extension of the range of x is done in this case. right : bool, default: True Indicates whether the bins include the rightmost edge or not. If right == True (the default), then the bins [1,2,3,4] indicate (1,2], (2,3], (3,4]. labels : array-like or bool, default: None Used as labels for the resulting bins. Must be of the same length as the resulting bins. If False, string bin labels are assigned by `pandas.cut`. precision : int, default: 3 The precision at which to store and display the bins labels. include_lowest : bool, default: False Whether the first interval should be left-inclusive or not. squeeze : bool, default: True If "group" is a dimension of any arrays in this dataset, `squeeze` controls whether the subarrays have a dimension of length 1 along that dimension or if the dimension is squeezed out. restore_coord_dims : bool, default: False If True, also restore the dimension order of multi-dimensional coordinates. Returns ------- grouped : DatasetGroupBy A `DatasetGroupBy` object patterned after `pandas.GroupBy` that can be iterated over in the form of `(unique_value, grouped_array)` pairs. The name of the group has the added suffix `_bins` in order to distinguish it from the original variable. See Also -------- Dataset.groupby DataArray.groupby_bins core.groupby.DatasetGroupBy pandas.DataFrame.groupby References ---------- .. [1] http://pandas.pydata.org/pandas-docs/stable/generated/pandas.cut.html rr`)r rrr)rjrrZ cut_kwargs)rra) rrrr rrrrjrrarrr groupby_bins"sB zDataset.groupby_binsrz)weightsrcCsddlm}|||S)ae Weighted Dataset operations. Parameters ---------- weights : DataArray An array of weights associated with the values in this Dataset. Each value in the data contributes to the reduction operation according to its associated weight. Notes ----- ``weights`` must be a DataArray and cannot contain missing values. Missing values can be replaced by ``weights.fillna(0)``. Returns ------- core.weighted.DatasetWeighted See Also -------- DataArray.weighted rry)xarray.core.weightedrz)rrrzrrrweightedL#s zDataset.weightedzbool | Mapping[Any, bool]rf)r min_periodscenter window_kwargsrcKs(ddlm}t||d}|||||dS)a Rolling window object for Datasets. Parameters ---------- dim : dict, optional Mapping from the dimension name to create the rolling iterator along (e.g. `time`) to its moving window size. min_periods : int or None, default: None Minimum number of observations in window required to have a value (otherwise result is NA). The default, None, is equivalent to setting min_periods equal to the size of the window. center : bool or Mapping to int, default: False Set the labels at the center of the window. **window_kwargs : optional The keyword arguments form of ``dim``. One of dim or window_kwargs must be provided. Returns ------- core.rolling.DatasetRolling See Also -------- core.rolling.DatasetRolling DataArray.rolling r)rfrolling)rr)xarray.core.rollingrfrM)rrrrrrfrrrrh#s"  zDataset.rollingrrmeanrhz'SideOptions | Mapping[Any, SideOptions]z-str | Callable | Mapping[Any, str | Callable]re)rboundaryside coord_funcrrcKs*ddlm}t||d}||||||dS)a Coarsen object for Datasets. Parameters ---------- dim : mapping of hashable to int, optional Mapping from the dimension name to the window size. boundary : {"exact", "trim", "pad"}, default: "exact" If 'exact', a ValueError will be raised if dimension size is not a multiple of the window size. If 'trim', the excess entries are dropped. If 'pad', NA will be padded. side : {"left", "right"} or mapping of str to {"left", "right"}, default: "left" coord_func : str or mapping of hashable to str, default: "mean" function (name) that is applied to the coordinates, or a mapping from coordinate name to function (name). Returns ------- core.rolling.DatasetCoarsen See Also -------- core.rolling.DatasetCoarsen DataArray.coarsen r)recoarsen)rrr)rrerM)rrrrrrrerrrr#s!  zDataset.coarsen start_dayzMapping[Any, str] | NonezSideOptions | Nonez.pd.Timedelta | datetime.timedelta | str | Nonezstr | DatetimeLikezdatetime.timedelta | str | Nonerd) rr8closedr%baseoffsetoriginrloffsetrindexer_kwargsrc Ks4ddlm} |jf| ||||||||| | d | S)a Returns a Resample object for performing resampling operations. Handles both downsampling and upsampling. The resampled dimension must be a datetime-like coordinate. If any intervals contain no values from the original object, they will be given the value ``NaN``. Parameters ---------- indexer : Mapping of Hashable to str, optional Mapping from the dimension name to resample frequency [1]_. The dimension must be datetime-like. skipna : bool, optional Whether to skip missing values when aggregating in downsampling. closed : {"left", "right"}, optional Side of each interval to treat as closed. label : {"left", "right"}, optional Side of each interval to use for labeling. base : int, optional For frequencies that evenly subdivide 1 day, the "origin" of the aggregated intervals. For example, for "24H" frequency, base could range from 0 through 23. origin : {'epoch', 'start', 'start_day', 'end', 'end_day'}, pd.Timestamp, datetime.datetime, np.datetime64, or cftime.datetime, default 'start_day' The datetime on which to adjust the grouping. The timezone of origin must match the timezone of the index. If a datetime is not used, these values are also supported: - 'epoch': `origin` is 1970-01-01 - 'start': `origin` is the first value of the timeseries - 'start_day': `origin` is the first day at midnight of the timeseries - 'end': `origin` is the last value of the timeseries - 'end_day': `origin` is the ceiling midnight of the last day offset : pd.Timedelta, datetime.timedelta, or str, default is None An offset timedelta added to the origin. loffset : timedelta or str, optional Offset used to adjust the resampled time labels. Some pandas date offset strings are supported. restore_coord_dims : bool, optional If True, also restore the dimension order of multi-dimensional coordinates. **indexer_kwargs : str The keyword arguments form of ``indexer``. One of indexer or indexer_kwargs must be provided. Returns ------- resampled : core.resample.DataArrayResample This object resampled. See Also -------- DataArray.resample pandas.Series.resample pandas.DataFrame.resample Dataset.groupby DataArray.groupby References ---------- .. [1] http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases rrc) Z resample_clsrr8rr%rrrrrr)xarray.core.resamplerdZ _resample) rrr8rr%rrrrrrrrdrrrresample#s K  zDataset.resample)NNN)N)NNNNN)NNNN)FN)FNN)N)N)NF) NrNNNNNTF)rNNNNNTF)rNNNNN) NrNNNNNTF) NNNNNNTNNNTNN)NNNNNN) NNNNNNTNNNTNN)N)r)NFr)NNNF)N)N)N)N)Nr=FNr>)r=FNr>)N)N)N)N)N)NN)NF)F)N)N)FF)T)rN)F)F)NN)N)N)rNN)Nr=NTN)N)N)N)Nr)Nr)N)rN)N)N)F)NF)TF)FN)rF)rr$)NF)T)Nr=FNNN)FN)rN)N)NF)N)rNN)NNNFF)NrqNNNNN)N)N)NrNr)NTNNNN)r)rNNN)r)TF)TNr`FTF)NNF)Nrrr) NNNNNNrNNN)rrr__doc____annotations__rr classmethodr<rrr.setterrrr?rr7rKrLrUrXr\r^rarcr`rbrErwrvrgrJr{r~rrrsrrrrrrrrrr rr rrrrrr$rr__hash__rr/rrr3rr-r,rrrrrrrrrrrr rrrrr!r"r*r+r.r8rr-r9r:r<rCrTrrr[r]rfrjrrgrhrlrvrrrrrr2rrrrrr frozensetrQrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrr'r*r1rLr:r=rKrOrMrQrRrVr!ZUncachedAccessorrWZplotr[r+r]rprxrzr~rrrrrrrrrrrrrrrrrrs. z$  '    3" 5Kg+ +  I@    ( $$ &"l* *(#(M+ ("`$+$X03X*>(D([((&b, 1)m  'r r 4<$=&6 v (5f*,d"<"7 9 GE$,";">R**h$?$`&  % OI.Z ,  Y H WY,7;"H ?8 K  _(o,G4= c a;>(d4:,(~" 9.R$)*.)N)r)NNrFF) __future__rrsdatetimerrrrr collectionsrhtmlrZnumbersroperatorrosrtypingrr r r r r rrrrrrrrrZnumpyrrrZxarray.coding.calendar_opsrrrrrrJrrrrrrr r!Zxarray.core._aggregationsr"rr#r$r%Zxarray.core.arithmeticr&Zxarray.core.commonr'r(r)rr+Zxarray.core.coordinatesr,r-Zxarray.core.duck_array_opsr.Zxarray.core.indexesr/r0r1r2r3r4r5r6r7r8Zxarray.core.indexingr9r:Zxarray.core.merger;r<r=r>rr?Zxarray.core.optionsr@rAZxarray.core.pycompatrBrCZxarray.core.typesrDrEZxarray.core.utilsrFrGrHrIrJrKrLrMrNrOrPrQrGrRrSrTrUrVZxarray.plot.accessorrWZ numpy.typingrXZxarray.backendsrYrZrr[r\r]rr_rrarbrrdrrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxrrzZ dask.delayedr{rRr r|rZ_DATETIMEINDEX_COMPONENTSrrrrrrrrrrrrrrs      D      0  8       P   %?   5