U Cv fw@srddlmZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZmZddlZddlZddlmZmZmZmZddlmZmZddlmZddlm Z m!Z!ddl"m#Z#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,dd l-m.Z.dd l/m0Z0ddl1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCddl5mDZDeZEddZFdBdddddZGddZHdd ZId!d"ZJd#d$ZKGd%d&d&ZLed'ed(d)eLfd*ZMd'd+d,d-d.d/ZNd'dd0d1d2ZOd3d4ZPGd5d6d6ee4ZQd7d8ZRGd9d:d:eQd(e ZSGd;d<dd>eQd?e!ZUGd@dAdAeUee$ZVdS)C) annotationsN) TYPE_CHECKINGAnyCallableGenericHashableIteratorLiteralMappingSequenceTypeVarUnioncast)dtypesduck_array_opsnputilsops)DataArrayGroupByAggregationsDatasetGroupByAggregations)align)DataArrayGroupbyArithmeticDatasetGroupbyArithmetic)ImplementsArrayReduceImplementsDatasetReduce)concat)format_array_flat)create_default_index_implicitfilter_indexes_from_coordssafe_cast_to_index)_get_keep_attrs) integer_types)DimsQuantileMethodsT_Xarray)either_dict_or_kwargshashable is_scalarmaybe_wrap_arraypeek_at) IndexVariableVariable) ArrayLike DataArrayDataset)FrozencsF|dk rBt|r|g}tfdd|DrBtd|dddS)N.c3s|]}|kVqdSN.0dim dimensionsr27/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/groupby.py Asz$check_reduce_dims..cannot reduce over dimensions zH. expected either '...' to reduce over all dimensions or one or more of .)r&any ValueError)Z reduce_dimsr7r2r6r8check_reduce_dims<sr>Tboolz-tuple[np.ndarray | pd.Index, list[list[int]]])sortreturncCsltj||d\}}t|tjr&|j|_ddtt|D}t|D]\}}|dkrD|||qD||fS)aGroup an array by its unique values. Parameters ---------- ar : array-like Input array. This will be flattened if it is not already 1-D. sort : bool, default: True Whether or not to sort unique values. Returns ------- values : np.ndarray Sorted, unique values as returned by `np.unique`. indices : list of lists of int Each element provides the integer indices in `ar` with values given by the corresponding value in `unique_values`. r@cSsg|]}gqSr2r2)r4_r2r2r8 _sz'unique_value_groups..r) pdZ factorize isinstance MultiIndexnamesrangelen enumerateappend)arr@Zinversevaluesgroupsngr2r2r8unique_value_groupsHs rRcsddlm}ddlm}t|rV|ddjDfddjDj}nBt|r|t j fddjDgj jd}nt |S) Nrr,r.cSsi|]\}}|t|jqSr2)rget_fill_valuedtyper4kvr2r2r8 msz_dummy_copy..cs(i|] \}}|jkr|t|jqSr2dimsrrSrTrU xarray_objr2r8rXqs cs(i|] \}}|jkr|t|jqSr2rYrUr[r2r8rX{s )rZnameattrs)xarray.core.dataarrayr-xarray.core.datasetr/rF data_varsitemscoordsr^rrSrTr]AssertionError)r\r-r/resr2r[r8 _dummy_copygs0        rfcCs|dkp|dkSNr2)objr2r2r8_is_one_or_nonesrjcCsg}td}|D]j}t|ts,td||rl|j|jkrlt|jrlt|jrlt|j|j|j}||d<q|||}q|S)z0Consolidate adjacent slices in a list of slices.Nzlist element is not a slice: )slicerFr=stopstartrjsteprL)ZslicesresultZ last_sliceZslice_r2r2r8_consolidate_slicess$    rqcCsL|sdSt|dtr.)rFrlrqrZinverse_permutationrrZ concatenate) positionsr2r2r8_inverse_permutation_indicess  rvc@seZdZdZdZddddddZed d d d Zed d ddZedd ddZ edd ddZ edd ddZ ddZ dS) _DummyGroupzhClass for keeping track of grouped dimensions without coordinates. Should not be user visible. )r]rcsizer#rNone)rir]rAcCs||_||_|j||_dSr1)r]rcsizesrx)selfrir]rcr2r2r8__init__sz_DummyGroup.__init__ztuple[Hashable]rAcCs|jfSr1r]r{r2r2r8rZsz_DummyGroup.dimsz Literal[1]cCsdSrgr2rr2r2r8ndimsz_DummyGroup.ndimrIcCs t|jSr1rIrxrr2r2r8rNsz_DummyGroup.valuescCs t|jSr1rrr2r2r8datasz_DummyGroup.dataz tuple[int]cCs|jfSr1)rxrr2r2r8shapesz_DummyGroup.shapecCst|tr|d}|j|SNr)rFtuplerNr{keyr2r2r8 __getitem__s z_DummyGroup.__getitem__N) __name__ __module__ __qualname____doc__ __slots__r|propertyrZrrNrrrr2r2r2r8rwsrwT_Groupr-r))boundr#z9tuple[T_Group, T_Xarray, Hashable | None, list[Hashable]])grouprirAcsddlm}tttfs$jdkr0|dgfSt|rj}ddtt |}fddjD} ||i }| ||i}t t ||||fStdtd dS) Nrr,rhZstacked_rCcsg|]}|jkr|qSr2)rcr3rr2r8rDs z_ensure_1d..z;group must be DataArray, IndexVariable or _DummyGroup, got r;)r_r-rFr)rwrrZjoinmapstrstackcopyrr TypeErrortype)rrir-Z orig_dims stacked_dim inserted_dimsZnewgroupZnewobjr2rr8 _ensure_1ds   r)rrAcCs"t|trdSt|}|jo |jS)NT)rFrwr is_uniqueis_monotonic_increasing)rindexr2r2r8_unique_and_monotonics rcCsLt|jtjtjfo.t|jtjo.t|jdk}|rB|j|j|_d|_dS)a (copied from pandas) if loffset is set, offset the result index This is NOT an idempotent routine, it will be applied exactly once to the result. Parameters ---------- result : Series or DataFrame the result of resample rN) rFZloffsetrEZ DateOffsetdatetime timedeltarZ DatetimeIndexrJ)grouperrpZ needs_offsetr2r2r8_apply_loffsets  rc @seZdZUdZdZded<dYddd d d d d d dddZeddddZdZddddddddZ d[dddddddd dd d ddd!d"d#Z ed$dd%d&Z d'dd(d)d*Z d+dd,d-Z d.dd/d0Zd1dd2d3Zd4d5Zd6dd7d8Zd9d:Zd\d;d<Zd=d>Zd?d@Zd]ddddAdBdCZdddDdEdFZd^dHddIdddJddKdLdMZejfdddNdOZdPdQZd_dddRdSdTZd`dddRdUdVZdadWdXZdS)bGroupBya A object that implements the split-apply-combine pattern. Modeled after `pandas.GroupBy`. The `GroupBy` object can be iterated over (unique_value, grouped_array) pairs, but the main way to interact with a groupby object are with the `apply` or `reduce` methods. You can also directly call numpy methods like `mean` or `std`. You should create a GroupBy object by using the `DataArray.groupby` or `Dataset.groupby` methods. See Also -------- Dataset.groupby DataArray.groupby ) _full_index_inserted_dims_group _group_dim_group_indices_groups_obj_restore_coord_dims _stacked_dim _unique_coord_dims_sizes_squeeze _original_obj_original_group_binsr#rFNTz$Hashable | DataArray | IndexVariabler?zpd.Grouper | NonezArrayLike | NonezMapping[Any, Any] | Nonery)rirsqueezerbinsrestore_coord_dims cut_kwargsrAcCs6|dkr i}ddlm}|dk r0|dk r0tdt||tfst|sVtd|d||}t|dkrzt|jd|j|j kr|j|j krt ||j|j }t |dddkrd |_||_ ||_||_t||\}}} } |j \} |j| } |j| krtd d} |dk rpt|r(td tj|j|f|d d i\}}t|jd}||t |dd|d}|j} |dk rt|}|jstd|||\} }|jtj }ddt!|dd|ddDt"|ddg}t|j|j#}n|j |jfkr.rkrhcSsg|]}t||dqS)rhr)r4rr2r2r8rDsZdroprBz.None of the data falls within bins with edges zEFailed to group data. Are you grouping by a variable that is all NaN?):r_r-rrFr)r%rJr=r]rcrZrwgetattrrrrrrzrxrisnullallrEZcutrNr categoriesrr_get_index_and_itemsZastyperrZint64ziprlrrrIrsr<whereZnotnulldropnarGrRrrrrrrrrrrrrr)r{rirrrrrrr-rrZ group_dimZ expected_size full_indexZbinnedZ new_dim_namer first_itemsZsbinsZ group_indicesZ unique_coordZgroup_as_indexr@Z unique_valuesr2r2r8r|Es"       "      zGroupBy.__init__Frozen[Hashable, int]r}cCs,|jdkr&|j|j|jdij|_|jS)zOrdered mapping from dimension names to lengths. Immutable. See Also -------- DataArray.sizes Dataset.sizes Nr)rriselrrrzrr2r2r8rzs z GroupBy.sizesr2rtuple[Any, ...] bool | NonerfuncargsshortcutkwargsrAcKs tdSr1NotImplementedErrorr{rrrrr2r2r8rsz GroupBy.mapaxis keep_attrskeepdimsrCallable[..., Any]r!int | Sequence[int] | Nonerr5rrrrrrAcKs tdSr1r)r{rr5rrrrrr2r2r8reduces zGroupBy.reducez'dict[GroupKey, slice | int | list[int]]cCs&|jdkr tt|jj|j|_|jS)zo Mapping from group labels to indices. The indices can be used to index the underlying object. N)rdictrrrNrrr2r2r8rOs zGroupBy.groupsGroupKey)rrAcCs|j|j|j|iS)zU Get DataArray or Dataset corresponding to a particular group label. )rrrrOrr2r2r8r szGroupBy.__getitem__intcCs|jjSr1)rrxrr2r2r8__len__szGroupBy.__len__z#Iterator[tuple[GroupKey, T_Xarray]]cCst|jj|Sr1)rrrN _iter_groupedrr2r2r8__iter__szGroupBy.__iter__rc Cs.d|jj|jj|jjdt|jdS)Nz1{}, grouped over {!r} {!r} groups with labels {}.z, ) format __class__rrr]rxrrsplitrr2r2r8__repr__s zGroupBy.__repr__cCspddlm}tt|j|}t||r6||}n| | }t |||j }| rh|}||fS)Nr) CFTimeGrouper)Zxarray.core.resample_cftimerrEZSeriesrrrsrxrFrgroupbyfirstrrrr<r)r{rrrsrrr2r2r8r!s     zGroupBy._get_index_and_itemszIterator[T_Xarray]ccs$|jD]}|j|j|iVqdS)z'Iterate over each element in this groupN)rrrr)r{indicesr2r2r8r/s zGroupBy._iter_groupedcCsP|j|jkr|j}|j}n |j}d}|j\}t|tr:d}t|d|}|||fS)Nvariable)rrZrrrrFrwr)r{applied_examplecoordrur5r2r2r8_infer_concat_args4s   zGroupBy._infer_concat_argscsddlm}ddlm}|s n fdd}|jdkrJ|j}|j}|j} n ||j }||j }|j f} t |t r||j}|} n|j} t | |s||j} |j} t |||fstd| |jkrtd| d|jD]4} || jdkr|| | | |j| i|| <qt|| d d \}} || |i}|||}|jd krt|jt|jD]:} t|| jt|jkrZ|| jd d ||| <qZt ||rt ||rt|D]6} | D]*}||| jkr|| |d|| <qq|S)Nrr,r.cs ||Sr1r2)xyfr2r8Ez$GroupBy._binary_op..zYGroupBy objects only support binary ops when the other argument is a Dataset or DataArrayzKincompatible dimensions for a grouped binary operation: the group variable z) is not a dimension on the other argumentouter)rrhTr.)r_r-r`r/rrrrZ_maybe_unstackrrrrFrwr]rrr=rcr drop_varsZ expand_dimsrzrselsetxindexesZ reset_coordsZbroadcast_like transpose)r{otherrZ reflexiver-r/rQrirrZrr]varrCexpandedrpdr2rr8 _binary_opAsT               zGroupBy._binary_opcCs6|jdk r2|jj|jkr2|jj|ji}|jf|}|S)zOur index contained empty groups (e.g., from a resampling). If we reduced on that dimension, we want to restore the full index. N)rrr]rZZreindex)r{combinedZindexersr2r2r8_maybe_restore_empty_groupss z#GroupBy._maybe_restore_empty_groupscCsX|jdk rT|j|jkrT||j}|jD]}||jkr(|j|=q(t|jt|j|_|S)zVThis gets called if we are applying on an array with a multidimensional group.N)rrZZunstackrrcr_indexesr)r{rir5r2r2r8rs    zGroupBy._maybe_unstack)r5rrc sddlm}ddlm}j}|dkr0tdd}|dd|d d}|rbd d |j D}ni}|dksz|j j krj j |j kr|j j j } | jrjrtd j j |d ddkrtjtrވjj njt} ttr*|jkr |jkr jdkr f} jt|tr>|f} n2|dkrPj} n |dkrhtjj} nt|} tfdd| Drtd |djdk rtjf} d} |ddkrd|ks|ddkrtj|d<d|d<|dtjnjjf} d} |j|f| | | |d|}|j| dd}| D]N\}t fdd| DrHj!"j fj|j#j fj$||<qHjdk rj%dk st&j%|j j <tj'|rj(j'jkr|)j j d}|S)zAAdaptor function that translates our groupby API to that of flox.r) xarray_reducer.NTdefaultmethodz split-reduce numeric_onlycSs2i|]*\}}t|jtjs|jtjks||qSr2)rrZ issubdtyperTnumberZbool_)r4r]rr2r2r8rXs  z(GroupBy._flox_reduce..r:r.c3s$|]}|jko|jjkVqdSr1)rZrr4r)rr{r2r8r9sz'GroupBy._flox_reduce..r;)TrcountZ fill_valuerhZ min_countF)r5expected_groupsisbinrignore)errorsc3s|]}|jkVqdSr1)rZr )rr2r8r9s)*Z flox.xarrayrr`r/rr setdefaultpoprarbrr]rindexesrrr=rFrrwrrrZrrr<rrarraynanrrNrrrZset_dimsrzrrrdrrr)r{r5rrrr/rir Z non_numericrZunindexed_dimsZ parsed_dimr rrpr]r2)rr{rr8 _flox_reduces            $             zGroupBy._flox_reduce)valuerAcCs t||S)aFill missing values in this object by group. 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 Used to fill all matching missing values by group. Needs to be of a valid type for the wrapped object's fillna method. Returns ------- same type as the grouped object See Also -------- Dataset.fillna DataArray.fillna )rfillna)r{rr2r2r8rszGroupBy.fillnalinearr+r"zQuantileMethods | None)qr5rrskipna interpolationrAc Cs0|dkr|jf}|j|jjjd||||||dS)a{Compute the qth quantile over each array in the groups and concatenate them together into a new array. Parameters ---------- q : float or sequence 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. Defaults to the grouped dimension. 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. Methods marked with an asterix require numpy version 1.22 or newer. The "method" argument was previously called "interpolation", renamed in accordance with numpy version 1.22.0. keep_attrs : bool or None, default: None If True, the dataarray's attributes (`attrs`) will be copied from the original object to the new one. If False, the new object will be returned without attributes. skipna : bool or None, default: None If True, skip missing values (as marked by NaN). By default, only skips missing values for float dtypes; other dtypes either do not have a sentinel missing value (int) or skipna=True has not been implemented (object, datetime64 or timedelta64). Returns ------- quantiles : Variable If `q` is a single quantile, then the result is a scalar. If multiple percentiles are given, first axis of the result corresponds to the quantile. In either case a quantile dimension is added to the return array. The other dimensions are the dimensions that remain after the reduction of the array. See Also -------- numpy.nanquantile, numpy.quantile, pandas.Series.quantile, Dataset.quantile DataArray.quantile Examples -------- >>> da = xr.DataArray( ... [[1.3, 8.4, 0.7, 6.9], [0.7, 4.2, 9.4, 1.5], [6.5, 7.3, 2.6, 1.9]], ... coords={"x": [0, 0, 1], "y": [1, 1, 2, 2]}, ... dims=("x", "y"), ... ) >>> ds = xr.Dataset({"a": da}) >>> da.groupby("x").quantile(0) array([[0.7, 4.2, 0.7, 1.5], [6.5, 7.3, 2.6, 1.9]]) Coordinates: * y (y) int64 1 1 2 2 quantile float64 0.0 * x (x) int64 0 1 >>> ds.groupby("y").quantile(0, dim=...) Dimensions: (y: 2) Coordinates: quantile float64 0.0 * y (y) int64 1 2 Data variables: a (y) float64 0.7 0.7 >>> da.groupby("x").quantile([0, 0.5, 1]) array([[[0.7 , 1. , 1.3 ], [4.2 , 6.3 , 8.4 ], [0.7 , 5.05, 9.4 ], [1.5 , 4.2 , 6.9 ]], [[6.5 , 6.5 , 6.5 ], [7.3 , 7.3 , 7.3 ], [2.6 , 2.6 , 2.6 ], [1.9 , 1.9 , 1.9 ]]]) Coordinates: * y (y) int64 1 1 2 2 * quantile (quantile) float64 0.0 0.5 1.0 * x (x) int64 0 1 >>> ds.groupby("y").quantile([0, 0.5, 1], dim=...) Dimensions: (y: 2, quantile: 3) Coordinates: * quantile (quantile) float64 0.0 0.5 1.0 * y (y) int64 1 2 Data variables: a (y, quantile) float64 0.7 5.35 8.4 0.7 2.25 9.4 References ---------- .. [1] R. J. Hyndman and Y. Fan, "Sample quantiles in statistical packages," The American Statistician, 50(4), pp. 361-365, 1996 NF)rrr5rrrr)rrrrquantile)r{rr5rrrrr2r2r8r1s~zGroupBy.quantilecCst|||S)a Return elements from `self` or `other` depending on `cond`. Parameters ---------- cond : DataArray or Dataset Locations at which to preserve this objects values. dtypes have to be `bool` other : scalar, DataArray or Dataset, optional Value to use for locations in this object where ``cond`` is False. By default, inserts missing values. Returns ------- same type as the grouped object See Also -------- Dataset.where )rZ where_method)r{Zcondrr2r2r8rsz GroupBy.wherecCs>t|jdtr|jS|dkr(tdd}|j||jg||dS)NrTr)r5rr)rFrr rrrr)r{oprrr2r2r8_first_or_lasts zGroupBy._first_or_last)rrcCs|tj||S)z@Return the first element of each group along the group dimension)rrrr{rrr2r2r8rsz GroupBy.firstcCs|tj||S)z?Return the last element of each group along the group dimension)rrlastr r2r2r8r!sz GroupBy.lastc st|d|fddS)zAssign coordinates by group. See Also -------- Dataset.assign_coords Dataset.swap_dims assign_coordscs |jfSr1)r"ds coords_kwargsr2r8rrz'GroupBy.assign_coords..)r$r)r{rcr&r2r%r8r"s zGroupBy.assign_coords)FNNTN)r2N)N)F)N)NrNNN)NN)NN)N) rrrrr__annotations__r|rrzrrrOrrrrrrrrrrrrrrZNArrrr!r"r2r2r2r8rsd     A   rcCs6t|}|dks"t||j|kr&|S|||iSdSr1)rvrJrz)r\r5ruorderr2r2r8_maybe_reordersr)c @seZdZUdZdZded<eddddZd d Zd'd d Z dddddZ d(ddddddddZ d)ddZ d*ddZ d+d d dddd d!d"dd#d#ddd$d%d&Zd S),DataArrayGroupByBasez8GroupBy object specialized to grouping DataArray objectsr2ztuple[Hashable, ...] | Nonerztuple[Hashable, ...]r}cCs,|jdkr&|j|j|jdij|_|jSrrrrrrrZrr2r2r8rZs zDataArrayGroupByBase.dimsccs(|jj}|jD]}||j|iVqdS)zWFast version of `_iter_grouped` that yields Variables without metadata N)rrrr)r{rrr2r2r8_iter_grouped_shortcuts z+DataArrayGroupByBase._iter_grouped_shortcutNcCs(tj||dd}t|||}|j|S)NTr)r*rr)rZ_replace_maybe_drop_dims)r{appliedr5rustackedZ reorderedr2r2r8_concat_shortcuts z%DataArrayGroupByBase._concat_shortcutr-)r/rAcs,fdd}t|j|d}|j|djiS)Ncs8|jjkrjj\}|jjkr0j|}nd}|S)Ng.A)rr]rZrZ get_axis_num)Z dimensionrrr2r8 lookup_orders    z=DataArrayGroupByBase._restore_dim_order..lookup_order)rZtranspose_coords)sortedrZrr)r{r/r1Z new_orderr2rr8_restore_dim_orders z'DataArrayGroupByBase._restore_dim_orderzCallable[..., DataArray]rrrrc s8|r |n|}fdd|D}|j||dS)aApply a function to each array in the group and concatenate them together into a new array. `func` is called like `func(ar, *args, **kwargs)` for each array `ar` in this group. Apply uses heuristics (like `pandas.GroupBy.apply`) to figure out how to stack together the array. The rule is: 1. If the dimension along which the group coordinate is defined is still in the first grouped array after applying `func`, then stack over this dimension. 2. Otherwise, stack over the new dimension given by name of this grouping (the argument to the `groupby` function). Parameters ---------- func : callable Callable to apply to each array. shortcut : bool, optional Whether or not to shortcut evaluation under the assumptions that: (1) The action of `func` does not depend on any of the array metadata (attributes or coordinates) but only on the data and dimensions. (2) The action of `func` creates arrays with homogeneous metadata, that is, with the same dimensions and attributes. If these conditions are satisfied `shortcut` provides significant speedup. This should be the case for many common groupby operations (e.g., applying numpy ufuncs). *args : tuple, optional Positional arguments passed to `func`. **kwargs Used to call `func(ar, **kwargs)` for each array `ar`. Returns ------- applied : DataArray The result of splitting, applying and combining this array. c3s$|]}t||fVqdSr1)r')r4Zarrrrrr2r8r9Xsz+DataArrayGroupByBase.map..r-)r,r_combine)r{rrrrZgroupedr.r2r4r8r's0zDataArrayGroupByBase.mapFcKs(tjdtdd|j|f||d|S)z Backward compatible implementation of ``map`` See Also -------- DataArrayGroupBy.map NGroupBy.apply may be deprecated in the future. Using GroupBy.map is encouraged stacklevelrrwarningswarnPendingDeprecationWarningr)r{rrrrr2r2r8apply[s zDataArrayGroupByBase.applyc st|\}}||\}}}|r0||||}nt||}t|||}t|t|jr`||}|dk r||j krt |\}fdd|D} | | |}| |}| |}|S)0Recombine the applied objects like the original.Ncsi|] }|qSr2r2r4rVrr2r8rXzsz1DataArrayGroupByBase._combine..)r(rr0rr)rFrrr3rZr_overwrite_indexesrr) r{r.rrrr5rur index_varsrr2rBr8r5js        zDataArrayGroupByBase._combineTrrr!rr?rc  sZdkr|jgdkr"tdddddfdd }t|j|j||dS) 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=axis, **kwargs)` to return the result of collapsing an np.ndarray over an integer valued axis. dim : "...", str, Iterable of Hashable or None, optional Dimension(s) over which to apply `func`. If None, apply over the groupby dimension, if "..." apply over all dimensions. axis : int or sequence of int, optional Axis(es) over which to apply `func`. Only one of the 'dimension' and 'axis' arguments can be supplied. If neither are supplied, then `func` is calculated over all dimension for each group item. keep_attrs : bool, optional If True, the datasets'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. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : Array Array with summarized data and the indicated dimension(s) removed. NTrr-)rMrAcs|jfdSN)rr5rrrr)rMrr5rrrrr2r8 reduce_arraysz1DataArrayGroupByBase.reduce..reduce_arrayr-rrr>rZr) r{rr5rrrrrrHr2rGr8rs(  zDataArrayGroupByBase.reduce)N)r2N)Fr2)F)N)rrrrrr'rrZr,r0r3rr?r5rr2r2r2r8r*s(  4  r*c@seZdZdZdS)DataArrayGroupByr2Nrrrrr2r2r2r8rJsrJc @seZdZUdZded<eddddZd"d d d d d dddZd#ddZddZ d$ddddddddd ddd d dddZ d d dd d!Z dS)%DatasetGroupByBaser2zFrozen[Hashable, int] | Nonerrr}cCs,|jdkr&|j|j|jdij|_|jSrr+rr2r2r8rZs zDatasetGroupByBase.dimsNzCallable[..., Dataset]rrrr/rc s$fdd|D}||S)a@Apply a function to each Dataset in the group and concatenate them together into a new Dataset. `func` is called like `func(ds, *args, **kwargs)` for each dataset `ds` in this group. Apply uses heuristics (like `pandas.GroupBy.apply`) to figure out how to stack together the datasets. The rule is: 1. If the dimension along which the group coordinate is defined is still in the first grouped item after applying `func`, then stack over this dimension. 2. Otherwise, stack over the new dimension given by name of this grouping (the argument to the `groupby` function). Parameters ---------- func : callable Callable to apply to each sub-dataset. args : tuple, optional Positional arguments to pass to `func`. **kwargs Used to call `func(ds, **kwargs)` for each sub-dataset `ar`. Returns ------- applied : Dataset The result of splitting, applying and combining this dataset. c3s|]}|fVqdSr1r2)r4r$r4r2r8r9sz)DatasetGroupByBase.map..)rr5)r{rrrrr.r2r4r8rs%zDatasetGroupByBase.mapcKs(tjdtdd|j|f||d|S)z} Backward compatible implementation of ``map`` See Also -------- DatasetGroupBy.map r6r7r8r:r;rr2r2r8r?s zDatasetGroupByBase.applyc st|\}}||\}}}t||}t|||}|dk rn||jkrnt|\}fdd|D}|||}||}||}|S)r@Ncsi|] }|qSr2r2rArBr2r8rXsz/DatasetGroupByBase._combine..) r(rrr)rZrrCrr) r{r.rrr5rurrDrr2rBr8r5 s       zDatasetGroupByBase._combineFTrrr!rr?rc  sVdkr|jgdkr"tdddddfdd }t|j||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=axis, **kwargs)` to return the result of collapsing 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 apply over the groupby dimension, with "..." apply over all dimensions. axis : int or sequence of int, optional Axis(es) over which to apply `func`. Only one of the 'dimension' and 'axis' arguments can be supplied. If neither are supplied, then `func` is calculated over all dimension for each group item. keep_attrs : bool, optional If True, the datasets'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. **kwargs : dict Additional keyword arguments passed on to `func`. Returns ------- reduced : Dataset Array with summarized data and the indicated dimension(s) removed. NTrr/)r$rAcs|jfdSrErFr#rGr2r8reduce_datasetGsz1DatasetGroupByBase.reduce..reduce_datasetrI) r{rr5rrrrrrMr2rGr8rs(  zDatasetGroupByBase.reduce)rrAc s|fddS)zbAssign data variables by group. See Also -------- Dataset.assign cs |jfSr1)assignr#rr2r8r\rz+DatasetGroupByBase.assign..)r)r{rr2rOr8rNUszDatasetGroupByBase.assign)r2N)r2N)N) rrrrr'rrZrr?r5rrNr2r2r2r8rLs"  (  rRrfrjrqrvrwrrrrrr)r*rJrLrPr2r2r2r8sr 8          "'W E