U Cv fe@sddlmZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZddlZddlmZmZmZddlmZddlmZmZddlmZddlmZmZmZdd l m!Z!z ddl"Z"Wne#k rdZ"YnXerdd l$m%Z%dd l&m'Z'eZ(ed Z)d Z*Gddde eZ+Gddde+dZ,Gddde+dZ-Gdddee eZ.Gddde.dZ/Gddde.dZ0dS)) annotationsN) TYPE_CHECKINGAnyCallableGenericHashableIteratorMappingTypeVar)dtypesduck_array_opsutils)CoarsenArithmetic)OPTIONS_get_keep_attrs)is_duck_dask_array)CoarsenBoundaryOptions SideOptionsT_Xarray)either_dict_or_kwargs DataArrayDataset_TaReduce this object's data windows by applying `{name}` along its dimension. Parameters ---------- keep_attrs : bool, default: None 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. If None uses the global default. **kwargs : dict Additional keyword arguments passed on to `{name}`. Returns ------- reduced : same type as caller New object with `{name}` applied along its rolling dimension. c@sHeZdZdZdZdZd=dddd d d d d ZddddZddddZe ddddZ d>dddddddZ ddZ e jdd e _e d!ejZe d"ejZe d#ejZe d$ejZe d%d&Ze d'd(Ze dde Ze d)dZe d*dZe d+dZd,dd-d.d/Zd?d,dd-d0d1Ze jd2d e_d@d4d5d6d6d7d8d9d:Zd;d<ZdS)ARollingzA object that implements the moving window pattern. See Also -------- xarray.Dataset.groupby xarray.DataArray.groupby xarray.Dataset.rolling xarray.DataArray.rolling )objwindow min_periodscenterdim)rrrr NFrMapping[Any, int] int | Nonebool | Mapping[Any, bool]NonerwindowsrrreturncCsg|_g|_|D]0\}}|j||dkr8td|j|q|j|dd|_||_|dk rt|dkrttd|dkrt |jn||_ dS)ac Moving window object. Parameters ---------- obj : Dataset or DataArray Object to window. windows : mapping of hashable to int A mapping from the name of the dimension to create the rolling window along (e.g. `time`) to the size of the moving window. 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 dict-like Hashable to bool, default: False Set the labels at the center of the window. If dict-like, set this property per rolling dimension. Returns ------- rolling : type of input argument rzwindow must be > 0FdefaultNz-min_periods must be greater than zero or None) r ritemsappend ValueError_mapping_to_listrrmathprodr)selfrr&rrdwr37/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/rolling.py__init__Is zRolling.__init__strr'cCs4ddt|j|j|jD}dj|jjd|dS)z-provide a nice str repr of our rolling objectcSs*g|]"\}}}dj|||rdnddqS)z {k}->{v}{c}z(center))kvc)format).0r9r2r;r3r3r4 |sz$Rolling.__repr__..{klass} [{attrs}],klassattrs)zipr rrr< __class____name__joinr0rCr3r3r4__repr__yszRolling.__repr__intcstfddjDS)Nc3s|]}jj|VqdSN)rsizesr=r1r0r3r4 sz"Rolling.__len__..)r.r/r rNr3rNr4__len__szRolling.__len__cCs t|jSrK)lenr rNr3r3r4ndimsz Rolling.ndimrzCallable | NonezCallable[..., T_Xarray])namefillnarolling_agg_funcr'csPr dn tt|ttd|ddfdd }||_tj|d|_|S)zConstructs reduction methods built on a numpy reduction function (e.g. sum), a bottleneck reduction function (e.g. move_sum), or a Rolling reduction (_mean).NZmove_cs&||}|jf|d|S)N) keep_attrsrT)r_numpy_or_bottleneck_reduce)r0rVkwargsarray_agg_funcbottleneck_move_funcrTrUr3r4methods z&Rolling._reduce_method..methodrS)N)getattrr bottleneckrF"_ROLLING_REDUCE_DOCSTRING_TEMPLATEr<__doc__)rSrTrUr\r3rYr4_reduce_methods  zRolling._reduce_methodcKs@|jfddi||jddj|jjdd}|r<|jj|_|S)NrVFrV)copy)sumcountZastyperdtyperC)r0rVrXresultr3r3r4_means z Rolling._meanmeanr]argmaxargminmaxminr/rerstdvarmedian bool | NonerVr'cCs tdSrK)NotImplementedErrorr0rVr3r3r4_countsszRolling._countscCs*||}|j|d}||jk}||SNrc)rrwrwhere)r0rVZ rolling_countZenough_periodsr3r3r4rfs   z Rolling.countrfTz_T | Mapping[Any, _T]z _T | Noneboolzlist[_T])argr) allow_default allow_allsamer'cstr\|r$fdd|jDS|jD]}|kr*td|dq*fdd|jDS|rlg|jS|jdkr|gStd|jddS) Ncsg|]}|qSr3getrMr{r)r3r4r>sz,Rolling._mapping_to_list..zArgument has no dimension key .csg|] }|qSr3r3rM)r{r3r4r>sroz"Mapping argument is necessary for z d-rolling.)r is_dict_liker KeyErrorrRr,)r0r{r)r|r}r1r3rr4r-s    zRolling._mapping_to_listcCs|dkrtdd}|SNTr(rrvr3r3r4rs zRolling._get_keep_attrs)NF)N)N)NTT) rF __module__ __qualname__ra __slots__ _attributesr5rIrPpropertyrRrbrir`r<r NINFrkINFrlrmrnr/rerjrprqrrrwrfr-rr3r3r3r4r;s@ 0           rc seZdZdZd'dddddd fd d Zd d ddZddejdfdddddddddZddejdfddddddddddZ d(dddddddZ ddd d!d"Z d#d$Z d%d&Z ZS))DataArrayRolling) window_labelsNFrr!r"r#r$r%cs*tj||||d|j|jd|_dS)a! Moving window object for DataArray. You should use DataArray.rolling() method to construct this object instead of the class constructor. Parameters ---------- obj : DataArray Object to window. windows : mapping of hashable to int A mapping from the name of the dimension to create the rolling exponential window along (e.g. `time`) to the size of the moving window. min_periods : int, 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, default: False Set the labels at the center of the window. Returns ------- rolling : type of input argument See Also -------- xarray.DataArray.rolling xarray.DataArray.groupby xarray.Dataset.rolling xarray.Dataset.groupby )rrrN)superr5rr r)r0rr&rrrEr3r4r5s%zDataArrayRolling.__init__z%Iterator[tuple[DataArray, DataArray]]r7c cs|jdkrtd|jd}t|jd}|jdr@|ddnd}t||jj ||}||}d|d||<t |j ||D]H\}}}|j |t ||i} | j|gd} | | |jk} || fVqdS)Nroz)__iter__ is only supported for 1d-rollingr)r )rRr,r rJrrnpZarangerrLrDriselslicerfryr) r0Zdim0Zwindow0offsetZstopsZstartslabelstartstoprcountsr3r3r4__iter__s  zDataArrayRolling.__iter__ro(Hashable | Mapping[Any, Hashable] | Noneint | Mapping[Any, int]rrsr window_dimstride fill_valuerVwindow_dim_kwargsr'cKs|j|jf||||d|S)aG Convert this rolling object to xr.DataArray, where the window dimension is stacked as a new dimension Parameters ---------- window_dim : Hashable or dict-like to Hashable, optional A mapping from dimension name to the new window dimension names. stride : int or mapping of int, default: 1 Size of stride for the rolling window. fill_value : default: dtypes.NA Filling value to match the dimension size. keep_attrs : bool, default: None 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. If None uses the global default. **window_dim_kwargs : Hashable, optional The keyword arguments form of ``window_dim`` {dim: new_name, ...}. Returns ------- DataArray that is a view of the original array. The returned array is not writeable. Examples -------- >>> da = xr.DataArray(np.arange(8).reshape(2, 4), dims=("a", "b")) >>> rolling = da.rolling(b=3) >>> rolling.construct("window_dim") array([[[nan, nan, 0.], [nan, 0., 1.], [ 0., 1., 2.], [ 1., 2., 3.]], [[nan, nan, 4.], [nan, 4., 5.], [ 4., 5., 6.], [ 5., 6., 7.]]]) Dimensions without coordinates: a, b, window_dim >>> rolling = da.rolling(b=3, center=True) >>> rolling.construct("window_dim") array([[[nan, 0., 1.], [ 0., 1., 2.], [ 1., 2., 3.], [ 2., 3., nan]], [[nan, 4., 5.], [ 4., 5., 6.], [ 5., 6., 7.], [ 6., 7., nan]]]) Dimensions without coordinates: a, b, window_dim )rrrrV) _constructr)r0rrrrVrr3r3r4 construct#sBzDataArrayRolling.construct)rrrrrVrr'c  sddlm}||}|dkrFtdkr2tdfdd|jD}|j|ddd}|j|dd } |jj|j|j ||j |d } |r|j ni} || |j t ||j| |jd } | d dt|j| DS) Nrrsz/DataArrayRolling._construct..Fr|r}ror()r)dimscoordsrCrScSsi|]\}}|tdd|qSrKrr=r1sr3r3r4rs)xarray.core.dataarrayrrrQr,r r-variableZrolling_windowrrrCrtuplerrSrrD) r0rrrrrVrr window_dimsstridesrrCrhr3rr4rns<    zDataArrayRolling._constructrfuncrVrXr'c  s|}fddjD}|dtj}|tjk rDj|}nj}j||||d}|j|ft | |d|}j dd} | | j kS)aReduce the items in this group by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `func(x, **kwargs)` to return the result of collapsing an np.ndarray over an the rolling dimension. keep_attrs : bool, default: None 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. If None uses the global default. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : DataArray Array with summarized data. Examples -------- >>> da = xr.DataArray(np.arange(8).reshape(2, 4), dims=("a", "b")) >>> rolling = da.rolling(b=3) >>> rolling.construct("window_dim") array([[[nan, nan, 0.], [nan, 0., 1.], [ 0., 1., 2.], [ 1., 2., 3.]], [[nan, nan, 4.], [nan, 4., 5.], [ 4., 5., 6.], [ 5., 6., 7.]]]) Dimensions without coordinates: a, b, window_dim >>> rolling.reduce(np.sum) array([[nan, nan, 3., 6.], [nan, nan, 15., 18.]]) Dimensions without coordinates: a, b >>> rolling = da.rolling(b=3, min_periods=1) >>> rolling.reduce(np.nansum) array([[ 0., 1., 3., 6.], [ 4., 9., 15., 18.]]) Dimensions without coordinates: a, b cs$i|]}|tjjd|qSZ _rolling_dim_r Zget_temp_dimnamerrrMrNr3r4rsz+DataArrayRolling.reduce..rT)rVr)r rVFrc)rr popr NArrTrreducelistvaluesrwryr) r0rrVrX rolling_dimrTrr&rhrr3rNr4rs07     zDataArrayRolling.reducertcsxfddjD}jj|djddtjjDfddtjDdj|d|djt | d|d }|S) z1Number of non-nan entries in each rolling window.cs$i|]}|tjjd|qSrrrMrNr3r4rsz,DataArrayRolling._counts..rccSsi|]\}}||qSr3r3)r=r1r2r3r3r4rscsi|]\}}|j|qSr3rr=ir1rNr3r4rsrF)rrV)r skipnarV) r rZnotnullZrollingrDr enumeraterrerr)r0rVrrr3rNr4rws"    zDataArrayRolling._countsc Ksbddlm}|jdk r&|jdkr&d}n|j}|j|jd}|jj}|jdrt|j r|j dd d}|j ddd} t df|t | | |jj |f} n0|j d dd}t df|t | df} |j |jdd| fidd}t|j r tdn||j |j d||d} |jdr8| | } |rF|jjni} || |jj| |jjd S) NrrrorZconstant)modezshould not be reachable)r min_countaxis)rCrS)rrrrZ get_axis_numr rrrdatarrshapepadAssertionErrorrCrrS) r0rrVrXrrrZpaddedshiftrZvalidrrCr3r3r4_bottleneck_reduces8       z#DataArrayRolling._bottleneck_reducecKsd|kr(tjd|jdtdd|d=tdrd|dk rdt|jjsd|jdkrd|j |fd|i|S|rz||| |d S|dk r|t j krt j |jjd d }n|t jkrt j|jjd d }|d d|d||j|fd|i|S)Nr z7Reductions are applied along the rolling dimension(s) 'zA'. Passing the 'dim' kwarg to reduction operations has no effect.) stacklevelZuse_bottleneckrorVrcT)Z max_for_int)Z min_for_intrFrT)warningswarnr DeprecationWarningrrrrrRrrr rZget_pos_infinityrgrZget_neg_infinity setdefaultr)r0rZr[rUrVrTrXr3r3r4rW&s@        z,DataArrayRolling._numpy_or_bottleneck_reduce)NF)N)rFrrrr5rr rrrrrwrrW __classcell__r3r3rr4rs(*N)P*rrcseZdZdZd!dddddd fd d Zd d Zd"dddddddZdddddZddZdde j dfddddddddd Z Z S)#DatasetRolling)rollingsNFrr!r"r#r$r%c st|||tfddjDr4tji_jjD]r\}}gi}}t jD]*\}} | |j krb| | j ||| <qb|rFfdd|D} t || ||j|<qFdS)a: Moving window object for Dataset. You should use Dataset.rolling() method to construct this object instead of the class constructor. Parameters ---------- obj : Dataset Object to window. windows : mapping of hashable to int A mapping from the name of the dimension to create the rolling exponential window along (e.g. `time`) to the size of the moving window. min_periods : int, 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 of hashable to bool, default: False Set the labels at the center of the window. Returns ------- rolling : type of input argument See Also -------- xarray.Dataset.rolling xarray.DataArray.rolling xarray.Dataset.groupby xarray.DataArray.groupby c3s|]}|jjkVqdSrKrrrMrNr3r4rO{sz*DatasetRolling.__init__..csi|]}||qSr3r3rMr&r3r4rsz+DatasetRolling.__init__..N)rr5anyr rrr data_varsr*rrr+rr) r0rr&rrkeydarrr1r2r)r0r&r4r5Us%    zDatasetRolling.__init__c sddlm}||}i}|jjD]`\}tfdd|jDrf||j|fd|i|||<q&|j| ||<|s&i||_ q&|r|jj ni}|||jj |dS)Nrrc3s|]}|jkVqdSrKrrMrr3r4rOsz9DatasetRolling._dataset_implementation..rVrrC) xarray.core.datasetrrrrr*rr rrdrCr)r0rrVrXrreducedrrCr3rr4_dataset_implementations    z&DatasetRolling._dataset_implementationrrsrrrcKs"|jtjtj|dfd|i|S)aReduce the items in this group by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `func(x, **kwargs)` to return the result of collapsing an np.ndarray over an the rolling dimension. keep_attrs : bool, default: None 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. If None uses the global default. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : DataArray Array with summarized data. rrV)r functoolspartialrr)r0rrVrXr3r3r4rszDatasetRolling.reducertcCs|jtj|dSrx)rrrwrvr3r3r4rwszDatasetRolling._countscKs&|jtjtj|||dfd|i|S)N)rZr[rUrV)rrrrrW)r0rZr[rUrVrXr3r3r4rWsz*DatasetRolling._numpy_or_bottleneck_reducerorrrrc  s>ddlm}||}|dkrFtdkr2tdfdd|jD}|j|ddd|j|d d i}|jj D]\}fd d |jD} | rfd dt |jD} fddt |jD} |j |j | || |d||<n ||<|sti||_qt|r|jjni} |||jj| dddt|jDS)a Convert this rolling object to xr.Dataset, where the window dimension is stacked as a new dimension Parameters ---------- window_dim : str or mapping, optional A mapping from dimension name to the new window dimension names. Just a string can be used for 1d-rolling. stride : int, optional size of stride for the rolling window. fill_value : Any, default: dtypes.NA Filling value to match the dimension size. **window_dim_kwargs : {dim: new_name, ...}, optional The keyword arguments form of ``window_dim``. Returns ------- Dataset with variables converted from rolling object. rrNrcsi|]}|t|qSr3rrMrr3r4rsz,DatasetRolling.construct..Frror(csg|]}|jkr|qSr3rrMrr3r4r>s z,DatasetRolling.construct..cs$i|]\}}|jkr||qSr3rr)rrr3r4rs cs$i|]\}}|jkr||qSr3rr)rrr3r4rs )rrrrVrcSsi|]\}}|tdd|qSrKrrr3r3r4rs)rrrrQr,r r-rrr*rrrrdrCrrrD) r0rrrrVrrZdatasetrrZwistrCr3)rrrrr4rsB       zDatasetRolling.construct)NF)N) rFrrrr5rrrwrWr rrrr3r3rr4rRs6rrc@s`eZdZUdZdZdZded<ddddd d d d d ZddZddddZ dddddZ dS)CoarsenzoA object that implements the coarsen. See Also -------- Dataset.coarsen DataArray.coarsen )rboundary coord_funcr&side trim_excess)r&rrrrr!rz'SideOptions | Mapping[Any, SideOptions]z-str | Callable | Mapping[Any, str | Callable]r$)rr&rrrr'cs|_|_|_|_fdd|D}|rNtd|djjjdt snfddjj Djj D]}|krvt j |<qv_dS) a* Moving window object. Parameters ---------- obj : Dataset or DataArray Object to window. windows : mapping of hashable to int A mapping from the name of the dimension to create the rolling exponential window along (e.g. `time`) to the size of the moving window. boundary : {"exact", "trim", "pad"} If 'exact', a ValueError will be raised if dimension size is not a multiple of window size. If 'trim', the excess indexes are trimmed. If 'pad', NA will be padded. side : 'left' or 'right' or mapping from dimension to 'left' or 'right' coord_func : function (name) or mapping from coordinate name to function (name). Returns ------- coarsen csg|]}|jjkr|qSr3rr=r rNr3r4r>Rs z$Coarsen.__init__..z Dimensions z not found in rcsi|] }|qSr3r3rM)rr3r4rXsz$Coarsen.__init__..N)rr&rrkeysr,rErFr rrrr rjr)r0rr&rrrZ absent_dimsr;r3)rr0r4r50s   zCoarsen.__init__cCs|dkrtdd}|Srrrvr3r3r4r^s zCoarsen._get_keep_attrsr6r7cs,fddjD}djjjd|dS)z-provide a nice str repr of our coarsen objectcs0g|](}t|ddk r|dt|qS)Nz->)r^)r=r9rNr3r4r>gsz$Coarsen.__repr__..r?r@rA)rr<rErFrGrHr3rNr4rIds zCoarsen.__repr__Nc sddlm}ddlm}t|ds0tdtddD}|rXtd||d krjtd d }t t j }|rtd |t j t }|rtd ||} t j |rЈj } nj } |r| jni| _| jD]\} ttjfddtjD} | jkrpfddD} | jj\}}|r\jni}| ||f| | <q| | <qt t j j@t j jB}| |}t j |rj |S|Sd S)a Convert this Coarsen object to a DataArray or Dataset, where the coarsening dimension is split or reshaped to two new dimensions. Parameters ---------- window_dim: mapping A mapping from existing dimension name to new dimension names. The size of the second dimension will be the length of the coarsening window. keep_attrs: bool, optional Preserve attributes if True **window_dim_kwargs : {dim: new_name, ...} The keyword arguments form of ``window_dim``. Returns ------- Dataset or DataArray with reshaped dimensions Examples -------- >>> da = xr.DataArray(np.arange(24), dims="time") >>> da.coarsen(time=12).construct(time=("year", "month")) 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]]) Dimensions without coordinates: year, month See Also -------- DataArrayRolling.construct DatasetRolling.construct rrrCoarsen.constructrcss,|]$\}}t|dks t|tr|VqdS)rN)rQ isinstancer6)r=winrr3r3r4rOs z$Coarsen.construct..zTPlease provide exactly two dimension names for the following coarsening dimensions: NTr(zI'window_dim' must contain entries for all dimensions to coarsen. Missing z='window_dim' includes dimensions that will not be coarsened: csg|]}||gqSr3r~r)rr3r4r>sz%Coarsen.construct..cs"i|]}|jkr|j|qSr3)rr&)r=r2)r0rqr3r4rs z%Coarsen.construct..)rrrrrr,rr*rsetr&rrZ_to_temp_datasetrC variables itertoolschainrrZcoarsen_reshaperrrZ set_coordsZ_from_temp_dataset)r0rrVrrrZ bad_new_dimsZ missing_dimsZ extra_windowsZreshapedrrZ reshaped_dimsr&Z reshaped_var_rCZshould_be_coordsrhr3)r0rqrr4rpsh)         r)NN) rFrrrarr__annotations__r5rrIrr3r3r3r4rs .rc@sBeZdZdZdZedddddddd Zddd d d ddZd S)DataArrayCoarsenr3r8FrrzzCallable[..., DataArray]rinclude_skipna numeric_onlyr'cs,i}|rd|d<d ddddfdd }|S) r Return a wrapped function for injecting reduction methods. see ops.inject_reduce_methods Nrrrsrr0rVr'csddlm}|}jjjjjj|f|}i}jj D]h\}}|jj krd|||<qFt fdd|j Dr|jjjj|jj|f|||<qF|||<qF||jj |jj dS)Nrrc3s|]}|jkVqdSrKrrMrNr3r4rOszHDataArrayCoarsen._reduce_method..wrapped_func..)rrrS)rrrrrcoarsenr&rrrr*rSrrr)r0rVrXrrrr;r:rrNr4 wrapped_funcs@     z5DataArrayCoarsen._reduce_method..wrapped_func)Nr3clsrrrrXrr3rr4rbs zDataArrayCoarsen._reduce_methodNrsr)rrVr'cKs||}||fd|i|S)aReduce the items in this group by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `func(x, axis, **kwargs)` to return the result of collapsing an np.ndarray over the coarsening dimensions. It must be possible to provide the `axis` argument with a tuple of integers. keep_attrs : bool, default: None 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. If None uses the global default. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : DataArray Array with summarized data. Examples -------- >>> da = xr.DataArray(np.arange(8).reshape(2, 4), dims=("a", "b")) >>> coarsen = da.coarsen(b=2) >>> coarsen.reduce(np.sum) array([[ 1, 5], [ 9, 13]]) Dimensions without coordinates: a, b rVrbr0rrVrXrr3r3r4r s# zDataArrayCoarsen.reduce)FF)NrFrrrZ_reduce_extra_args_docstring classmethodrbrr3r3r3r4rs,rc@s@eZdZdZdZedddddddd Zddd d d dZd S)DatasetCoarsenr3r8FrrzzCallable[..., Dataset]rcs,i}|rd|d<d ddddfdd }|S) rNrrrsrrc sddlm}||}|r$|jj}ni}i}|jjD]0\}}|jj|j |j |j fd|i|||<q8i}|jj D]6\} } | jj|j |j | |j |j fd|i||| <qz||||dS)NrrrVr)rrrrrCrr*rrr&rrrr) r0rVrXrrCrrrrr;r:rr3r4rDs<     z3DatasetCoarsen._reduce_method..wrapped_func)Nr3rr3rr4rb8s &zDatasetCoarsen._reduce_methodNr)rr'cKs||}||fd|i|S)anReduce the items in this group by applying `func` along some dimension(s). Parameters ---------- func : callable Function which can be called in the form `func(x, axis, **kwargs)` to return the result of collapsing an np.ndarray over the coarsening dimensions. It must be possible to provide the `axis` argument with a tuple of integers. keep_attrs : bool, default: None 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. If None uses the global default. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : Dataset Arrays with summarized data. rVrrr3r3r4rls zDatasetCoarsen.reduce)FF)Nrr3r3r3r4r3s3r)1 __future__rrrr.rtypingrrrrrrr r ZnumpyrZ xarray.corer r r Zxarray.core.arithmeticrZxarray.core.optionsrrZxarray.core.pycompatrZxarray.core.typesrrrZxarray.core.utilsrr_ ImportErrorrrrrZ RollingKeyrr`rrrrrrr3r3r3r4sB (        )qK@X