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.

__init__(dataset)[source]#

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 as weighted=False.

Parameters
  • data_var (str) – The key of the data variable for calculating 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 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

1

https://xarray.pydata.org/en/stable/user-guide/groupby.html#grouped-arithmetic

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

5

https://cfconventions.org/cf-conventions/cf-conventions.html#calendar

_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

2

https://xarray.pydata.org/en/stable/user-guide/time-series.html#datetime-components

_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

3

https://docs.xarray.dev/en/stable/user-guide/weather-climate.html#non-standard-calendars-and-dates-outside-the-timestamp-valid-range

4

https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timestamp-limitations

_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.