xcdat.temporal.TemporalAccessor
xcdat.temporal.TemporalAccessor#
- class xcdat.temporal.TemporalAccessor(dataset)[source]#
An accessor class that provides temporal attributes and methods on xarray Datasets through the
.temporal
attribute.Examples
Import TemporalAccessor class:
>>> import xcdat # or from xcdat import temporal
Use TemporalAccessor class:
>>> ds = xcdat.open_dataset("/path/to/file") >>> >>> ds.temporal.<attribute> >>> ds.temporal.<method> >>> ds.temporal.<property>
Check the ‘axis’ attribute is set on the time coordinates:
>>> ds.time.attrs["axis"] >>> T
Set the ‘axis’ attribute for the time coordinates if it isn’t:
>>> ds.time.attrs["axis"] = "T"
- Parameters
dataset (
xr.Dataset
) – A Dataset object.
Methods
__init__
(dataset)average
(data_var[, weighted, keep_weights])Returns a Dataset with the average of a data variable and the time dimension removed.
climatology
(data_var, freq[, weighted, ...])Returns a Dataset with the climatology of a data variable.
departures
(data_var, freq[, weighted, ...])Returns a Dataset with the climatological departures (anomalies) for a data variable.
group_average
(data_var, freq[, weighted, ...])Returns a Dataset with average of a data variable by time group.
- average(data_var, weighted=True, keep_weights=False)[source]#
Returns a Dataset with the average of a data variable and the time dimension removed.
This method is particularly useful for calculating the weighted averages of monthly or yearly time series data because the number of days per month/year can vary based on the calendar type, which can affect weighting. For other frequencies, the distribution of weights will be equal so
weighted=True
is the same asweighted=False
.- Parameters
data_var (
str
) – The key of the data variable for calculating averagesweighted (
bool
, optional) – Calculate averages using weights, by default True.Weights are calculated by first determining the length of time for each coordinate point using the difference of its upper and lower bounds. The time lengths are grouped, then each time length is divided by the total sum of the time lengths to get the weight of each coordinate point.
The weight of masked (missing) data is excluded when averages are taken. This is the same as giving them a weight of 0.
keep_weights (
bool
, optional) – If calculating averages using weights, keep the weights in the final dataset output, by default False.
- Returns
xr.Dataset
– Dataset with the average of the data variable and the time dimension removed.
Examples
Get weighted averages for a monthly time series data variable:
>>> ds_month = ds.temporal.average("ts", freq="month") >>> ds_month.ts
- group_average(data_var, freq, weighted=True, keep_weights=False, season_config={'custom_seasons': None, 'dec_mode': 'DJF', 'drop_incomplete_djf': False})[source]#
Returns a Dataset with average of a data variable by time group.
- Parameters
data_var (
str
) – The key of the data variable for calculating time series averages.freq (
Frequency
) – The time frequency to group by.“year”: groups by year for yearly averages.
“season”: groups by (year, season) for seasonal averages.
“month”: groups by (year, month) for monthly averages.
“day”: groups by (year, month, day) for daily averages.
“hour”: groups by (year, month, day, hour) for hourly averages.
weighted (
bool
, optional) – Calculate averages using weights, by default True.Weights are calculated by first determining the length of time for each coordinate point using the difference of its upper and lower bounds. The time lengths are grouped, then each time length is divided by the total sum of the time lengths to get the weight of each coordinate point.
The weight of masked (missing) data is excluded when averages are calculated. This is the same as giving them a weight of 0.
keep_weights (
bool
, optional) – If calculating averages using weights, keep the weights in the final dataset output, by default False.season_config (
SeasonConfigInput
, optional) – A dictionary for “season” frequency configurations. If configs for predefined seasons are passed, configs for custom seasons are ignored and vice versa.Configs for predefined seasons:
- “dec_mode” (Literal[“DJF”, “JFD”], by default “DJF”)
The mode for the season that includes December.
“DJF”: season includes the previous year December.
- “JFD”: season includes the same year December.
Xarray labels the season with December as “DJF”, but it is actually “JFD”.
- “drop_incomplete_djf” (bool, by default False)
If the “dec_mode” is “DJF”, this flag drops (True) or keeps (False) time coordinates that fall under incomplete DJF seasons Incomplete DJF seasons include the start year Jan/Feb and the end year Dec.
Configs for custom seasons:
- “custom_seasons” ([List[List[str]]], by default None)
List of sublists containing month strings, with each sublist representing a custom season.
Month strings must be in the three letter format (e.g., ‘Jan’)
Each month must be included once in a custom season
Order of the months in each custom season does not matter
Custom seasons can vary in length
>>> # Example of custom seasons in a three month format: >>> custom_seasons = [ >>> ["Jan", "Feb", "Mar"], # "JanFebMar" >>> ["Apr", "May", "Jun"], # "AprMayJun" >>> ["Jul", "Aug", "Sep"], # "JunJulAug" >>> ["Oct", "Nov", "Dec"], # "OctNovDec" >>> ]
- Returns
xr.Dataset
– Dataset with the average of a data variable by time group.
Examples
Get seasonal averages for a data variable:
>>> ds_season = ds.temporal.group_average( >>> "ts", >>> "season", >>> season_config={ >>> "dec_mode": "DJF", >>> "drop_incomplete_season": True >>> } >>> ) >>> ds_season.ts >>> >>> ds_season_with_jfd = ds.temporal.group_average( >>> "ts", >>> "season", >>> season_config={"dec_mode": "JFD"} >>> ) >>> ds_season_with_jfd.ts
Get seasonal averages with custom seasons for a data variable:
>>> custom_seasons = [ >>> ["Jan", "Feb", "Mar"], # "JanFebMar" >>> ["Apr", "May", "Jun"], # "AprMayJun" >>> ["Jul", "Aug", "Sep"], # "JunJulAug" >>> ["Oct", "Nov", "Dec"], # "OctNovDec" >>> ] >>> >>> ds_season_custom = ds.temporal.group_average( >>> "ts", >>> "season", >>> season_config={"custom_seasons": custom_seasons} >>> )
Get the
average()
operation attributes:>>> ds_season_with_djf.ts.attrs { 'operation': 'temporal_avg', 'mode': 'average', 'freq': 'season', 'weighted': 'True', 'dec_mode': 'DJF', 'drop_incomplete_djf': 'False' }
- climatology(data_var, freq, weighted=True, keep_weights=False, season_config={'custom_seasons': None, 'dec_mode': 'DJF', 'drop_incomplete_djf': False})[source]#
Returns a Dataset with the climatology of a data variable.
- Parameters
data_var (
str
) – The key of the data variable for calculating climatology.freq (
Frequency
) – The time frequency to group by.“season”: groups by season for the seasonal cycle climatology.
“month”: groups by month for the annual cycle climatology.
“day”: groups by (month, day) for the daily cycle climatology. Leap days (if present) are dropped if the CF calendar type is
"gregorian"
,"proleptic_gregorian"
, or"standard"
weighted (
bool
, optional) – Calculate averages using weights, by default True.Weights are calculated by first determining the length of time for each coordinate point using the difference of its upper and lower bounds. The time lengths are grouped, then each time length is divided by the total sum of the time lengths to get the weight of each coordinate point.
The weight of masked (missing) data is excluded when averages are taken. This is the same as giving them a weight of 0.
keep_weights (
bool
, optional) – If calculating averages using weights, keep the weights in the final dataset output, by default False.season_config (
SeasonConfigInput
, optional) – A dictionary for “season” frequency configurations. If configs for predefined seasons are passed, configs for custom seasons are ignored and vice versa.Configs for predefined seasons:
- “dec_mode” (Literal[“DJF”, “JFD”], by default “DJF”)
The mode for the season that includes December.
“DJF”: season includes the previous year December.
- “JFD”: season includes the same year December.
Xarray labels the season with December as “DJF”, but it is actually “JFD”.
- “drop_incomplete_djf” (bool, by default False)
If the “dec_mode” is “DJF”, this flag drops (True) or keeps (False) time coordinates that fall under incomplete DJF seasons Incomplete DJF seasons include the start year Jan/Feb and the end year Dec.
Configs for custom seasons:
- “custom_seasons” ([List[List[str]]], by default None)
List of sublists containing month strings, with each sublist representing a custom season.
Month strings must be in the three letter format (e.g., ‘Jan’)
Each month must be included once in a custom season
Order of the months in each custom season does not matter
Custom seasons can vary in length
>>> # Example of custom seasons in a three month format: >>> custom_seasons = [ >>> ["Jan", "Feb", "Mar"], # "JanFebMar" >>> ["Apr", "May", "Jun"], # "AprMayJun" >>> ["Jul", "Aug", "Sep"], # "JunJulAug" >>> ["Oct", "Nov", "Dec"], # "OctNovDec" >>> ]
- Returns
xr.Dataset
– Dataset with the climatology of a data variable.
Examples
Get a data variable’s seasonal climatology:
>>> ds_season = ds.temporal.climatology( >>> "ts", >>> "season", >>> season_config={ >>> "dec_mode": "DJF", >>> "drop_incomplete_season": True >>> } >>> ) >>> ds_season.ts >>> >>> ds_season = ds.temporal.climatology( >>> "ts", >>> "season", >>> season_config={"dec_mode": "JFD"} >>> ) >>> ds_season.ts
Get a data variable’s seasonal climatology with custom seasons:
>>> custom_seasons = [ >>> ["Jan", "Feb", "Mar"], # "JanFebMar" >>> ["Apr", "May", "Jun"], # "AprMayJun" >>> ["Jul", "Aug", "Sep"], # "JunJulAug" >>> ["Oct", "Nov", "Dec"], # "OctNovDec" >>> ] >>> >>> ds_season_custom = ds.temporal.climatology( >>> "ts", >>> "season", >>> season_config={"custom_seasons": custom_seasons} >>> )
Get
climatology()
operation attributes:>>> ds_season_with_djf.ts.attrs { 'operation': 'temporal_avg', 'mode': 'climatology', 'freq': 'season', 'weighted': 'True', 'dec_mode': 'DJF', 'drop_incomplete_djf': 'False' }
- departures(data_var, freq, weighted=True, keep_weights=False, season_config={'custom_seasons': None, 'dec_mode': 'DJF', 'drop_incomplete_djf': False})[source]#
Returns a Dataset with the climatological departures (anomalies) for a data variable.
In climatology, “anomalies” refer to the difference between the value during a given time interval (e.g., the January average surface air temperature) and the long-term average value for that time interval (e.g., the average surface temperature over the last 30 Januaries).
This method uses xarray’s grouped arithmetic as a shortcut for mapping over all unique labels. Grouped arithmetic works by assigning a grouping label to each time coordinate of the observation data based on the averaging mode and frequency. Afterwards, the corresponding climatology is removed from the observation data at each time coordinate based on the matching labels.
xarray’s grouped arithmetic operates over each value of the DataArray corresponding to each grouping label without changing the size of the DataArray. For example,the original monthly time coordinates are maintained when calculating seasonal departures on monthly data.
- Parameters
data_var (
str
) – The key of the data variable for calculating departures.freq (
Frequency
) – The frequency of time to group by.“season”: groups by season for the seasonal cycle departures.
“month”: groups by month for the annual cycle departures.
“day”: groups by (month, day) for the daily cycle departures. Leap days (if present) are dropped if the CF calendar type is
"gregorian"
,"proleptic_gregorian"
, or"standard"
- weightedbool, optional
Calculate averages using weights, by default True.
Weights are calculated by first determining the length of time for each coordinate point using the difference of its upper and lower bounds. The time lengths are grouped, then each time length is divided by the total sum of the time lengths to get the weight of each coordinate point.
The weight of masked (missing) data is excluded when averages are taken. This is the same as giving them a weight of 0.
- keep_weightsbool, optional
If calculating averages using weights, keep the weights in the final dataset output, by default False.
- season_config: SeasonConfigInput, optional
A dictionary for “season” frequency configurations. If configs for predefined seasons are passed, configs for custom seasons are ignored and vice versa.
Configs for predefined seasons:
- “dec_mode” (Literal[“DJF”, “JFD”], by default “DJF”)
The mode for the season that includes December.
“DJF”: season includes the previous year December.
- “JFD”: season includes the same year December.
Xarray labels the season with December as “DJF”, but it is actually “JFD”.
- “drop_incomplete_djf” (bool, by default False)
If the “dec_mode” is “DJF”, this flag drops (True) or keeps (False) time coordinates that fall under incomplete DJF seasons Incomplete DJF seasons include the start year Jan/Feb and the end year Dec.
Configs for custom seasons:
- “custom_seasons” ([List[List[str]]], by default None)
List of sublists containing month strings, with each sublist representing a custom season.
Month strings must be in the three letter format (e.g., ‘Jan’)
Each month must be included once in a custom season
Order of the months in each custom season does not matter
Custom seasons can vary in length
>>> # Example of custom seasons in a three month format: >>> custom_seasons = [ >>> ["Jan", "Feb", "Mar"], # "JanFebMar" >>> ["Apr", "May", "Jun"], # "AprMayJun" >>> ["Jul", "Aug", "Sep"], # "JunJulAug" >>> ["Oct", "Nov", "Dec"], # "OctNovDec" >>> ]
- Returns
xr.Dataset
– The Dataset containing the departures for a data var’s climatology.
Notes
Refer to 1 to learn more about how xarray’s grouped arithmetic works.
References
Examples
Get a data variable’s annual cycle departures:
>>> ds_depart = ds_climo.temporal.departures("ts", "month")
Get the
departures()
operation attributes:>>> ds_depart.ts.attrs { 'operation': 'departures', 'frequency': 'season', 'weighted': 'True', 'dec_mode': 'DJF', 'drop_incomplete_djf': 'False' }
- _infer_freq()[source]#
Infers the time frequency from the coordinates.
This method infers the time frequency from the coordinates by calculating the minimum delta and comparing it against a set of conditionals.
The native
xr.infer_freq()
method does not work for all cases because the frequency can be irregular (e.g., different hour measurements), which ends up returning None.- Returns
Frequency
– The time frequency.
- _averager(data_var, mode, freq, weighted=True, keep_weights=False, season_config={'custom_seasons': None, 'dec_mode': 'DJF', 'drop_incomplete_djf': False})[source]#
Averages a data variable based on the averaging mode and frequency.
- _set_data_var_attrs(data_var)[source]#
Set data variable metadata as object attributes.
This includes the name of the data variable, the time axis dimension name, the calendar type and its corresponding cftime object (date type).
- Parameters
data_var (
str
) – The key of the data variable.- Raises
KeyError – If the data variable does not have a “calendar” encoding attribute.
- _set_arg_attrs(mode, freq, weighted, season_config={'custom_seasons': None, 'dec_mode': 'DJF', 'drop_incomplete_djf': False})[source]#
Validates method arguments and sets them as object attributes.
- Parameters
mode (
Mode
) – The mode for temporal averaging.freq (
Frequency
) – The frequency of time to group by.weighted (
bool
) – Calculate averages using weights.season_config (
Optional[SeasonConfigInput]
) – A dictionary for “season” frequency configurations. If configs for predefined seasons are passed, configs for custom seasons are ignored and vice versa, by default DEFAULT_SEASON_CONFIG.
- Raises
KeyError – If the Dataset does not have a time dimension.
ValueError – If an incorrect
freq
arg was passed.ValueError – If an incorrect
dec_mode
arg was passed.
- _form_seasons(custom_seasons)[source]#
Forms custom seasons from a nested list of months.
This method concatenates the strings in each sublist to form a a flat list of custom season strings
- Parameters
custom_seasons (
List[List[str]]
) – List of sublists containing month strings, with each sublist representing a custom season.- Returns
Dict[str
,List[str]]
– A dictionary with the keys being the custom season and the values being the corresponding list of months.- Raises
ValueError – If exactly 12 months are not passed in the list of custom seasons.
ValueError – If a duplicate month(s) were found in the list of custom seasons.
ValueError – If a month string(s) is not supported.
- _preprocess_dataset(ds)[source]#
Preprocess the dataset based on averaging settings.
- Preprocessing operations include:
Drop incomplete DJF seasons (leading/trailing)
Drop leap days
- Parameters
ds (
xr.Dataset
) – The dataset.- Returns
xr.Dataset
- _drop_incomplete_djf(dataset)[source]#
Drops incomplete DJF seasons within a continuous time series.
This method assumes that the time series is continuous and removes the leading and trailing incomplete seasons (e.g., the first January and February of a time series that are not complete, because the December of the previous year is missing). This method does not account for or remove missing time steps anywhere else.
- Parameters
dataset (
xr.Dataset
) – The dataset with some possibly incomplete DJF seasons.- Returns
xr.Dataset
– The dataset with only complete DJF seasons.
- _drop_leap_days(ds)[source]#
Drop leap days from time coordinates.
This method is used to drop 2/29 from leap years (if present) before calculating climatology/departures for high frequency time series data to avoid cftime breaking (ValueError: invalid day number provided in cftime.DatetimeProlepticGregorian(1, 2, 29, 0, 0, 0, 0, has_year_zero=True).
- Parameters
ds (
xr.Dataset
) – The dataset.- Returns
xr.Dataset
- _average(data_var, time_bounds)[source]#
Averages a data variable with the time dimension removed.
- Parameters
data_var (
xr.DataArray
) – The data variable.time_bounds (
xr.DataArray
) – The time bounds.
- Returns
xr.DataArray
– The averages for a data variable with the time dimension removed.
- _group_average(data_var, time_bounds)[source]#
Averages a data variable by time group.
- Parameters
data_var (
xr.DataArray
) – The data variable.time_bounds (
xr.DataArray
) – The time bounds.
- Returns
xr.DataArray
– The data variable averaged by time group.
- _get_weights(time_bounds)[source]#
Calculates weights for a data variable using time bounds.
This method gets the length of time for each coordinate point by using the difference in the upper and lower time bounds. This approach ensures that the correct time lengths are calculated regardless of how time coordinates are recorded (e.g., monthly, daily, hourly) and the calendar type used.
The time lengths are labeled and grouped, then each time length is divided by the total sum of the time lengths in its group to get its corresponding weight.
The sum of the weights for each group is validated to ensure it equals 1.0.
- Parameters
time_bounds (
xr.DataArray
) – The time bounds.- Returns
xr.DataArray
– The weights based on a specified frequency.
Notes
Refer to 5 for the supported CF convention calendar types.
References
- _group_data(data_var)[source]#
Groups a data variable.
This method groups a data variable by a single datetime component for the “average” mode or labeled time coordinates for all other modes.
- Parameters
data_var (
xr.DataArray
) – A data variable.- Returns
DataArrayGroupBy
– A data variable grouped by label.
- _label_time_coords(time_coords)[source]#
Labels time coordinates with a group for grouping.
This methods labels time coordinates for grouping by first extracting specific xarray datetime components from time coordinates and storing them in a pandas DataFrame. After processing (if necessary) is performed on the DataFrame, it is converted to a numpy array of datetime objects. This numpy serves as the data source for the final DataArray of labeled time coordinates.
- Parameters
time_coords (
xr.DataArray
) – The time coordinates.- Returns
xr.DataArray
– The DataArray of labeled time coordinates for grouping.
Examples
Original daily time coordinates:
>>> <xarray.DataArray 'time' (time: 4)> >>> array(['2000-01-01T12:00:00.000000000', >>> '2000-01-31T21:00:00.000000000', >>> '2000-03-01T21:00:00.000000000', >>> '2000-04-01T03:00:00.000000000'], >>> dtype='datetime64[ns]') >>> Coordinates: >>> * time (time) datetime64[ns] 2000-01-01T12:00:00 ... 2000-04-01T03:00:00
Daily time coordinates labeled by year and month:
>>> <xarray.DataArray 'time' (time: 3)> >>> array(['2000-01-01T00:00:00.000000000', >>> '2000-03-01T00:00:00.000000000', >>> '2000-04-01T00:00:00.000000000'], >>> dtype='datetime64[ns]') >>> Coordinates: >>> * time (time) datetime64[ns] 2000-01-01T00:00:00 ... 2000-04-01T00:00:00
- _get_df_dt_components(time_coords)[source]#
Returns a DataFrame of xarray datetime components.
This method extracts the applicable xarray datetime components from each time coordinate based on the averaging mode and frequency, and stores them in a DataFrame.
Additional processing is performed for the seasonal frequency, including:
If custom seasons are used, map them to each time coordinate based on the middle month of the custom season.
If season with December is “DJF”, shift Decembers over to the next year so DJF seasons are correctly grouped using the previous year December.
Drop obsolete columns after processing is done.
- Parameters
time_coords (
xr.DataArray
) – The time coordinates.- Returns
pd.DataFrame
– A DataFrame of datetime components.
Notes
Refer to 2 for information on xarray datetime accessor components.
References
- _process_season_df(df)[source]#
Processes a DataFrame of datetime components for the season frequency.
- Parameters
df (
pd.DataFrame
) – A DataFrame of xarray datetime components.- Returns
pd.DataFrame
– A DataFrame of processed xarray datetime components.
- _map_months_to_custom_seasons(df)[source]#
Maps the month column in the DataFrame to a custom season.
This method maps each integer value in the “month” column to its string represention, which then maps to a custom season that is stored in the “season” column. For example, the month of 1 maps to “Jan” and “Jan” maps to the “JanFebMar” custom season.
- Parameters
df (
pd.DataFrame
) – The DataFrame of xarray datetime components.- Returns
pd.DataFrame
– The DataFrame of xarray datetime coordinates, with each row mapped to a custom season.
- _shift_decembers(df_season)[source]#
Shifts Decembers over to the next year for “DJF” seasons in-place.
For “DJF” seasons, Decembers must be shifted over to the next year in order for the xarray groupby operation to correctly label and group the corresponding time coordinates. If the aren’t shifted over, grouping is incorrectly performed with the native xarray “DJF” season (which is actually “JFD”).
- Parameters
df_season (
pd.DataFrame
) – The DataFrame of xarray datetime components produced using the “season” frequency.- Returns
pd.DataFrame
– The DataFrame of xarray datetime components with Decembers shifted over to the next year.
Examples
Comparison of “JFD” and “DJF” seasons:
>>> # "JFD" (native xarray behavior) >>> [(2000, "DJF", 1), (2000, "DJF", 2), (2000, "DJF", 12), >>> (2001, "DJF", 1), (2001, "DJF", 2)]
>>> # "DJF" (shifted Decembers) >>> [(2000, "DJF", 1), (2000, "DJF", 2), (2001, "DJF", 12), >>> (2001, "DJF", 1), (2001, "DJF", 2)]
- _map_seasons_to_mid_months(df)[source]#
Maps the season column values to the integer of its middle month.
DateTime objects don’t support storing seasons as strings, so the middle months are used to represent the season. For example, for the season “DJF”, the middle month “J” is mapped to the integer value 1.
The middle month of a custom season is extracted using the ceiling of the middle index from its list of months. For example, for the custom season “FebMarAprMay” with the list of months [“Feb”, “Mar”, “Apr”, “May”], the index 3 is used to get the month “Apr”. “Apr” is then mapped to the integer value 4.
After mapping the season to its month, the “season” column is renamed to “month”.
- Parameters
df (
pd.DataFrame
) – The dataframe of datetime components, including a “season” column.- Returns
pd.DataFrame
– The dataframe of datetime components, including a “month” column.
- _drop_obsolete_columns(df_season)[source]#
Drops obsolete columns from the DataFrame of xarray datetime components.
For the “season” frequency, processing is required on the DataFrame of xarray datetime components, such as mapping custom seasons based on the month. Additional datetime component values must be included as DataFrame columns, which become obsolete after processing is done. The obsolete columns are dropped from the DataFrame before grouping time coordinates.
- Parameters
df_season (
pd.DataFrame
) – The DataFrame of time coordinates for the “season” frequency with obsolete columns.- Returns
pd.DataFrame
– The DataFrame of time coordinates for the “season” frequency with obsolete columns dropped.
- _convert_df_to_dt(df)[source]#
Converts a DataFrame of datetime components to cftime datetime objects.
datetime objects require at least a year, month, and day value. However, some modes and time frequencies don’t require year, month, and/or day for grouping. For these cases, use default values of 1 in order to meet this datetime requirement.
- Parameters
df (
pd.DataFrame
) – The DataFrame of xarray datetime components.- Returns
np.ndarray
– A numpy ndarray of cftime.datetime objects.
Notes
Refer to 3 and 4 for more information on Timestamp-valid range. We use cftime.datetime objects to avoid these time range issues.
References
- _keep_weights(ds)[source]#
Keep the weights in the dataset.
- Parameters
ds (
xr.Dataset
) – The dataset.- Returns
xr.Dataset
– The dataset with the weights used for averaging.
- _add_operation_attrs(data_var)[source]#
Adds attributes to the data variable describing the operation. These attributes distinguish a data variable that has been operated on from its original state. The attributes in netCDF4 files do not support booleans or nested dictionaries, so booleans are converted to strings and nested dictionaries are unpacked.
- Parameters
data_var (
xr.DataArray
) – The data variable.- Returns
xr.DataArray
– The data variable with a temporal averaging attributes.