diff --git a/doc/contributing.rst b/doc/contributing.rst index b930b443dbd..2a91759744b 100644 --- a/doc/contributing.rst +++ b/doc/contributing.rst @@ -580,9 +580,9 @@ a user passes ``old_arg``, we would instead catch it: def func(new_arg, old_arg=None): if old_arg is not None: - from warnings import warn + from xarray.core.utils import emit_user_level_warning - warn( + emit_user_level_warning( "`old_arg` has been deprecated, and in the future will raise an error." "Please use `new_arg` from now on.", DeprecationWarning, diff --git a/doc/user-guide/weather-climate.rst b/doc/user-guide/weather-climate.rst index ac50c27d233..d56811aa2ad 100644 --- a/doc/user-guide/weather-climate.rst +++ b/doc/user-guide/weather-climate.rst @@ -98,13 +98,18 @@ coordinate with dates from a no-leap calendar and a ] da = xr.DataArray(np.arange(24), coords=[dates], dims=["time"], name="foo") -Xarray also includes a :py:func:`~xarray.cftime_range` function, which enables +Xarray also includes a :py:func:`~xarray.date_range` function, which enables creating a :py:class:`~xarray.CFTimeIndex` with regularly-spaced dates. For -instance, we can create the same dates and DataArray we created above using: +instance, we can create the same dates and DataArray we created above using +(note that ``use_cftime=True`` is not mandatory to return a +:py:class:`~xarray.CFTimeIndex` for non-standard calendars, but can be nice +to use to be explicit): .. ipython:: python - dates = xr.cftime_range(start="0001", periods=24, freq="MS", calendar="noleap") + dates = xr.date_range( + start="0001", periods=24, freq="MS", calendar="noleap", use_cftime=True + ) da = xr.DataArray(np.arange(24), coords=[dates], dims=["time"], name="foo") Mirroring pandas' method with the same name, :py:meth:`~xarray.infer_freq` allows one to @@ -138,7 +143,9 @@ use ``pandas`` when possible, i.e. when the calendar is ``standard``/``gregorian .. ipython:: python - dates = xr.cftime_range(start="2001", periods=24, freq="MS", calendar="noleap") + dates = xr.date_range( + start="2001", periods=24, freq="MS", calendar="noleap", use_cftime=True + ) da_nl = xr.DataArray(np.arange(24), coords=[dates], dims=["time"], name="foo") da_std = da.convert_calendar("standard", use_cftime=True) diff --git a/doc/whats-new.rst b/doc/whats-new.rst index a10a8c8851f..94ab5832f2a 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -38,6 +38,9 @@ Breaking changes Deprecations ~~~~~~~~~~~~ +- Deprecate :py:func:`~xarray.cftime_range` in favor of :py:func:`~xarray.date_range` with ``use_cftime=True`` + (:issue:`9886`, :pull:`10024`). + By `Josh Kihm `_. - Move from phony_dims=None to phony_dims="access" for h5netcdf-backend(:issue:`10049`, :pull:`10058`) By `Kai Mühlbauer `_. diff --git a/xarray/coding/cftime_offsets.py b/xarray/coding/cftime_offsets.py index f3ed6444904..22ba0aa3ce1 100644 --- a/xarray/coding/cftime_offsets.py +++ b/xarray/coding/cftime_offsets.py @@ -47,7 +47,7 @@ from collections.abc import Mapping from datetime import datetime, timedelta from functools import partial -from typing import TYPE_CHECKING, ClassVar, Literal, TypeVar +from typing import TYPE_CHECKING, ClassVar, Literal, TypeVar, get_args import numpy as np import pandas as pd @@ -66,11 +66,11 @@ count_not_none, default_precision_timestamp, ) +from xarray.core.types import InclusiveOptions from xarray.core.utils import attempt_import, emit_user_level_warning if TYPE_CHECKING: from xarray.core.types import ( - InclusiveOptions, PDDatetimeUnitOptions, Self, TypeAlias, @@ -855,15 +855,17 @@ def normalize_date(date): return date.replace(hour=0, minute=0, second=0, microsecond=0) -def _maybe_normalize_date(date, normalize): - """Round datetime down to midnight if normalize is True.""" - if normalize: - return normalize_date(date) - else: +def _get_normalized_cfdate(date, calendar, normalize): + """convert to cf datetime and round down to midnight if normalize.""" + if date is None: return date + cf_date = to_cftime_datetime(date, calendar) + + return normalize_date(cf_date) if normalize else cf_date + -def _generate_linear_range(start, end, periods): +def _generate_linear_date_range(start, end, periods): """Generate an equally-spaced sequence of cftime.datetime objects between and including two dates (whose length equals the number of periods).""" if TYPE_CHECKING: @@ -880,9 +882,9 @@ def _generate_linear_range(start, end, periods): ) -def _generate_range(start, end, periods, offset): +def _generate_linear_date_range_with_freq(start, end, periods, freq): """Generate a regular range of cftime.datetime objects with a - given time offset. + given frequency. Adapted from pandas.tseries.offsets.generate_range (now at pandas.core.arrays.datetimes._generate_range). @@ -895,13 +897,15 @@ def _generate_range(start, end, periods, offset): End of range periods : int, or None Number of elements in the sequence - offset : BaseCFTimeOffset - An offset class designed for working with cftime.datetime objects + freq: str + Step size between cftime.datetime objects. Not None. Returns ------- - A generator object + A generator object of cftime.datetime objects """ + offset = to_offset(freq) + if start: # From pandas GH 56147 / 56832 to account for negative direction and # range bounds @@ -951,6 +955,9 @@ def cftime_range( ) -> CFTimeIndex: """Return a fixed frequency CFTimeIndex. + .. deprecated:: 2025.02.0 + Use :py:func:`~xarray.date_range` with ``use_cftime=True`` instead. + Parameters ---------- start : str or cftime.datetime, optional @@ -1102,7 +1109,9 @@ def cftime_range( This function returns a ``CFTimeIndex``, populated with ``cftime.datetime`` objects associated with the specified calendar type, e.g. - >>> xr.cftime_range(start="2000", periods=6, freq="2MS", calendar="noleap") + >>> xr.date_range( + ... start="2000", periods=6, freq="2MS", calendar="noleap", use_cftime=True + ... ) CFTimeIndex([2000-01-01 00:00:00, 2000-03-01 00:00:00, 2000-05-01 00:00:00, 2000-07-01 00:00:00, 2000-09-01 00:00:00, 2000-11-01 00:00:00], dtype='object', length=6, calendar='noleap', freq='2MS') @@ -1118,52 +1127,96 @@ def cftime_range( -------- pandas.date_range """ + emit_user_level_warning( + "cftime_range() is deprecated, please use xarray.date_range(..., use_cftime=True) instead.", + DeprecationWarning, + ) + + return date_range( + start=start, + end=end, + periods=periods, + freq=freq, + normalize=normalize, + name=name, + inclusive=inclusive, + calendar=calendar, + use_cftime=True, + ) + + +def _cftime_range( + start=None, + end=None, + periods=None, + freq=None, + normalize=False, + name=None, + inclusive: InclusiveOptions = "both", + calendar="standard", +) -> CFTimeIndex: + """Return a fixed frequency CFTimeIndex. + Parameters + ---------- + start : str or cftime.datetime, optional + Left bound for generating dates. + end : str or cftime.datetime, optional + Right bound for generating dates. + periods : int, optional + Number of periods to generate. + freq : str or None, default: "D" + Frequency strings can have multiples, e.g. "5h" and negative values, e.g. "-1D". + normalize : bool, default: False + Normalize start/end dates to midnight before generating date range. + name : str, default: None + Name of the resulting index + inclusive : {"both", "neither", "left", "right"}, default "both" + Include boundaries; whether to set each bound as closed or open. + calendar : str, default: "standard" + Calendar type for the datetimes. + + Returns + ------- + CFTimeIndex + + Notes + ----- + see cftime_range + """ if freq is None and any(arg is None for arg in [periods, start, end]): freq = "D" # Adapted from pandas.core.indexes.datetimes._generate_range. if count_not_none(start, end, periods, freq) != 3: raise ValueError( - "Of the arguments 'start', 'end', 'periods', and 'freq', three " - "must be specified at a time." + "Exactly three of 'start', 'end', 'periods', or 'freq' must be " + "specified to generate a date range. Note that 'freq' defaults to " + "'D' in the event that any of 'start', 'end', or 'periods' are " + "None." ) - if start is not None: - start = to_cftime_datetime(start, calendar) - start = _maybe_normalize_date(start, normalize) - if end is not None: - end = to_cftime_datetime(end, calendar) - end = _maybe_normalize_date(end, normalize) + start = _get_normalized_cfdate(start, calendar, normalize) + end = _get_normalized_cfdate(end, calendar, normalize) if freq is None: - dates = _generate_linear_range(start, end, periods) - else: - offset = to_offset(freq) - dates = np.array(list(_generate_range(start, end, periods, offset))) - - if inclusive == "neither": - left_closed = False - right_closed = False - elif inclusive == "left": - left_closed = True - right_closed = False - elif inclusive == "right": - left_closed = False - right_closed = True - elif inclusive == "both": - left_closed = True - right_closed = True + dates = _generate_linear_date_range(start, end, periods) else: + dates = np.array( + list(_generate_linear_date_range_with_freq(start, end, periods, freq)) + ) + + if not TYPE_CHECKING and inclusive not in get_args(InclusiveOptions): raise ValueError( f"Argument `inclusive` must be either 'both', 'neither', " - f"'left', 'right', or None. Got {inclusive}." + f"'left', or 'right'. Got {inclusive}." ) - if not left_closed and len(dates) and start is not None and dates[0] == start: - dates = dates[1:] - if not right_closed and len(dates) and end is not None and dates[-1] == end: - dates = dates[:-1] + if len(dates) and inclusive != "both": + if inclusive != "left" and dates[0] == start: + dates = dates[1:] + if inclusive != "right" and dates[-1] == end: + dates = dates[:-1] return CFTimeIndex(dates, name=name) @@ -1218,12 +1271,153 @@ def date_range( If True, always return a CFTimeIndex. If False, return a pd.DatetimeIndex if possible or raise a ValueError. If None (default), return a pd.DatetimeIndex if possible, - otherwise return a CFTimeIndex. Defaults to False if `tz` is not None. + otherwise return a CFTimeIndex. Overridden to False if `tz` is not None. Returns ------- CFTimeIndex or pd.DatetimeIndex + Notes + ----- + When ``use_cftime=True``, or a calendar other than "standard", "gregorian", + or "proleptic_gregorian" is provided, this function is an analog of ``pandas.date_range`` + for use in generating sequences of ``cftime.datetime`` objects. It supports most of the + features of ``pandas.date_range`` (e.g. specifying how the index is + ``closed`` on either side, or whether or not to ``normalize`` the start and + end bounds); however, there are some notable exceptions: + + - You cannot specify a ``tz`` (time zone) argument. + - Start or end dates specified as partial-datetime strings must use the + `ISO-8601 format `_. + - It supports many, but not all, frequencies supported by + ``pandas.date_range``. For example it does not currently support any of + the business-related or semi-monthly frequencies. + - Compound sub-monthly frequencies are not supported, e.g. '1H1min', as + these can easily be written in terms of the finest common resolution, + e.g. '61min'. + + Valid simple frequency strings for use with ``cftime``-calendars include + any multiples of the following. + + +--------+--------------------------+ + | Alias | Description | + +========+==========================+ + | YE | Year-end frequency | + +--------+--------------------------+ + | YS | Year-start frequency | + +--------+--------------------------+ + | QE | Quarter-end frequency | + +--------+--------------------------+ + | QS | Quarter-start frequency | + +--------+--------------------------+ + | ME | Month-end frequency | + +--------+--------------------------+ + | MS | Month-start frequency | + +--------+--------------------------+ + | D | Day frequency | + +--------+--------------------------+ + | h | Hour frequency | + +--------+--------------------------+ + | min | Minute frequency | + +--------+--------------------------+ + | s | Second frequency | + +--------+--------------------------+ + | ms | Millisecond frequency | + +--------+--------------------------+ + | us | Microsecond frequency | + +--------+--------------------------+ + + Any multiples of the following anchored offsets are also supported. + + +------------+--------------------------------------------------------------------+ + | Alias | Description | + +============+====================================================================+ + | Y(E,S)-JAN | Annual frequency, anchored at the (end, beginning) of January | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-FEB | Annual frequency, anchored at the (end, beginning) of February | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-MAR | Annual frequency, anchored at the (end, beginning) of March | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-APR | Annual frequency, anchored at the (end, beginning) of April | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-MAY | Annual frequency, anchored at the (end, beginning) of May | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-JUN | Annual frequency, anchored at the (end, beginning) of June | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-JUL | Annual frequency, anchored at the (end, beginning) of July | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-AUG | Annual frequency, anchored at the (end, beginning) of August | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-SEP | Annual frequency, anchored at the (end, beginning) of September | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-OCT | Annual frequency, anchored at the (end, beginning) of October | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-NOV | Annual frequency, anchored at the (end, beginning) of November | + +------------+--------------------------------------------------------------------+ + | Y(E,S)-DEC | Annual frequency, anchored at the (end, beginning) of December | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-JAN | Quarter frequency, anchored at the (end, beginning) of January | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-FEB | Quarter frequency, anchored at the (end, beginning) of February | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-MAR | Quarter frequency, anchored at the (end, beginning) of March | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-APR | Quarter frequency, anchored at the (end, beginning) of April | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-MAY | Quarter frequency, anchored at the (end, beginning) of May | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-JUN | Quarter frequency, anchored at the (end, beginning) of June | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-JUL | Quarter frequency, anchored at the (end, beginning) of July | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-AUG | Quarter frequency, anchored at the (end, beginning) of August | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-SEP | Quarter frequency, anchored at the (end, beginning) of September | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-OCT | Quarter frequency, anchored at the (end, beginning) of October | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-NOV | Quarter frequency, anchored at the (end, beginning) of November | + +------------+--------------------------------------------------------------------+ + | Q(E,S)-DEC | Quarter frequency, anchored at the (end, beginning) of December | + +------------+--------------------------------------------------------------------+ + + Finally, the following calendar aliases are supported. + + +--------------------------------+---------------------------------------+----------------------------+ + | Alias | Date type | Available use_cftime=False | + +================================+=======================================+============================+ + | standard, gregorian | ``cftime.DatetimeGregorian`` | True | + +--------------------------------+---------------------------------------+----------------------------+ + | proleptic_gregorian | ``cftime.DatetimeProlepticGregorian`` | True | + +--------------------------------+---------------------------------------+----------------------------+ + | noleap, 365_day | ``cftime.DatetimeNoLeap`` | False | + +--------------------------------+---------------------------------------+----------------------------+ + | all_leap, 366_day | ``cftime.DatetimeAllLeap`` | False | + +--------------------------------+---------------------------------------+----------------------------+ + | 360_day | ``cftime.Datetime360Day`` | False | + +--------------------------------+---------------------------------------+----------------------------+ + | julian | ``cftime.DatetimeJulian`` | False | + +--------------------------------+---------------------------------------+----------------------------+ + + As in the standard pandas function, exactly three of ``start``, ``end``, + ``periods``, or ``freq`` are required to generate a date range. Note that + ``freq`` defaults to ``"D"`` in the event that any of ``start``, ``end``, + or ``periods`` are set to ``None``. See :py:func:`pandas.date_range`. + for more examples of the behavior of ``date_range`` with each of the + parameters. + + Examples + -------- + This function returns a ``CFTimeIndex``, populated with ``cftime.datetime`` + objects associated with the specified calendar type, e.g. + + >>> xr.date_range( + ... start="2000", periods=6, freq="2MS", calendar="noleap", use_cftime=True + ... ) + CFTimeIndex([2000-01-01 00:00:00, 2000-03-01 00:00:00, 2000-05-01 00:00:00, + 2000-07-01 00:00:00, 2000-09-01 00:00:00, 2000-11-01 00:00:00], + dtype='object', length=6, calendar='noleap', freq='2MS') + See also -------- pandas.date_range @@ -1259,7 +1453,7 @@ def date_range( f"Invalid calendar {calendar} for pandas DatetimeIndex, try using `use_cftime=True`." ) - return cftime_range( + return _cftime_range( start=start, end=end, periods=periods, diff --git a/xarray/coding/cftimeindex.py b/xarray/coding/cftimeindex.py index 7ef7ad894a6..053e4e76a3d 100644 --- a/xarray/coding/cftimeindex.py +++ b/xarray/coding/cftimeindex.py @@ -236,7 +236,7 @@ class CFTimeIndex(pd.Index): See Also -------- - cftime_range + date_range """ _data: np.ndarray @@ -463,7 +463,7 @@ def shift( # type: ignore[override] # freq is typed Any, we are more precise ) -> Self: """Shift the CFTimeIndex a multiple of the given frequency. - See the documentation for :py:func:`~xarray.cftime_range` for a + See the documentation for :py:func:`~xarray.date_range` for a complete listing of valid frequency strings. Parameters @@ -483,7 +483,7 @@ def shift( # type: ignore[override] # freq is typed Any, we are more precise Examples -------- - >>> index = xr.cftime_range("2000", periods=1, freq="ME") + >>> index = xr.date_range("2000", periods=1, freq="ME", use_cftime=True) >>> index CFTimeIndex([2000-01-31 00:00:00], dtype='object', length=1, calendar='standard', freq=None) @@ -586,7 +586,9 @@ def to_datetimeindex( Examples -------- - >>> times = xr.cftime_range("2000", periods=2, calendar="gregorian") + >>> times = xr.date_range( + ... "2000", periods=2, calendar="gregorian", use_cftime=True + ... ) >>> times CFTimeIndex([2000-01-01 00:00:00, 2000-01-02 00:00:00], dtype='object', length=2, calendar='standard', freq=None) @@ -652,8 +654,12 @@ def strftime(self, date_format): Examples -------- - >>> rng = xr.cftime_range( - ... start="2000", periods=5, freq="2MS", calendar="noleap" + >>> rng = xr.date_range( + ... start="2000", + ... periods=5, + ... freq="2MS", + ... calendar="noleap", + ... use_cftime=True, ... ) >>> rng.strftime("%B %d, %Y, %r") Index(['January 01, 2000, 12:00:00 AM', 'March 01, 2000, 12:00:00 AM', diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 4ba0f0a73a2..c245a0f9b55 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -5625,7 +5625,7 @@ def map_blocks( ... clim = gb.mean(dim="time") ... return gb - clim ... - >>> time = xr.cftime_range("1990-01", "1992-01", freq="ME") + >>> time = xr.date_range("1990-01", "1992-01", freq="ME", use_cftime=True) >>> month = xr.DataArray(time.month, coords={"time": time}, dims=["time"]) >>> np.random.seed(123) >>> array = xr.DataArray( diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index 449f502c43a..1197a27d4d1 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -8898,7 +8898,7 @@ def map_blocks( ... clim = gb.mean(dim="time") ... return gb - clim ... - >>> time = xr.cftime_range("1990-01", "1992-01", freq="ME") + >>> time = xr.date_range("1990-01", "1992-01", freq="ME", use_cftime=True) >>> month = xr.DataArray(time.month, coords={"time": time}, dims=["time"]) >>> np.random.seed(123) >>> array = xr.DataArray( diff --git a/xarray/core/parallel.py b/xarray/core/parallel.py index 6d6a6672470..1b2afbe516b 100644 --- a/xarray/core/parallel.py +++ b/xarray/core/parallel.py @@ -296,7 +296,7 @@ def map_blocks( ... clim = gb.mean(dim="time") ... return gb - clim ... - >>> time = xr.cftime_range("1990-01", "1992-01", freq="ME") + >>> time = xr.date_range("1990-01", "1992-01", freq="ME", use_cftime=True) >>> month = xr.DataArray(time.month, coords={"time": time}, dims=["time"]) >>> np.random.seed(123) >>> array = xr.DataArray( diff --git a/xarray/core/resample_cftime.py b/xarray/core/resample_cftime.py index c084640e763..949a95e32de 100644 --- a/xarray/core/resample_cftime.py +++ b/xarray/core/resample_cftime.py @@ -50,7 +50,7 @@ QuarterEnd, Tick, YearEnd, - cftime_range, + date_range, normalize_date, to_offset, ) @@ -219,8 +219,8 @@ def _get_time_bins( first, last = _get_range_edges( index.min(), index.max(), freq, closed=closed, origin=origin, offset=offset ) - datetime_bins = labels = cftime_range( - freq=freq, start=first, end=last, name=index.name + datetime_bins = labels = date_range( + freq=freq, start=first, end=last, name=index.name, use_cftime=True ) datetime_bins, labels = _adjust_bin_edges( diff --git a/xarray/tests/test_backends.py b/xarray/tests/test_backends.py index 83d5afa6a09..a6df4d7b0cb 100644 --- a/xarray/tests/test_backends.py +++ b/xarray/tests/test_backends.py @@ -50,7 +50,7 @@ from xarray.backends.scipy_ import ScipyBackendEntrypoint from xarray.backends.zarr import ZarrStore from xarray.coders import CFDatetimeCoder, CFTimedeltaCoder -from xarray.coding.cftime_offsets import cftime_range +from xarray.coding.cftime_offsets import date_range from xarray.coding.strings import check_vlen_dtype, create_vlen_dtype from xarray.coding.variables import SerializationWarning from xarray.conventions import encode_dataset_coordinates @@ -3299,7 +3299,7 @@ def test_chunked_datetime64_or_timedelta64(self, dtype) -> None: @requires_dask def test_chunked_cftime_datetime(self) -> None: # Based on @malmans2's test in PR #8253 - times = cftime_range("2000", freq="D", periods=3) + times = date_range("2000", freq="D", periods=3, use_cftime=True) original = xr.Dataset(data_vars={"chunked_times": (["time"], times)}) original = original.chunk({"time": 1}) with self.roundtrip(original, open_kwargs={"chunks": {}}) as actual: diff --git a/xarray/tests/test_cftime_offsets.py b/xarray/tests/test_cftime_offsets.py index 086e187d2e6..abec4c62080 100644 --- a/xarray/tests/test_cftime_offsets.py +++ b/xarray/tests/test_cftime_offsets.py @@ -1,9 +1,8 @@ from __future__ import annotations import warnings -from collections.abc import Callable from itertools import product -from typing import Literal +from typing import TYPE_CHECKING, Literal import numpy as np import pandas as pd @@ -1230,15 +1229,16 @@ def test_cftime_range( if isinstance(end, tuple): end = date_type(*end) - result = cftime_range( - start=start, - end=end, - periods=periods, - freq=freq, - inclusive=inclusive, - normalize=normalize, - calendar=calendar, - ) + with pytest.warns(DeprecationWarning): + result = cftime_range( + start=start, + end=end, + periods=periods, + freq=freq, + inclusive=inclusive, + normalize=normalize, + calendar=calendar, + ) resulting_dates = result.values assert isinstance(result, CFTimeIndex) @@ -1255,11 +1255,11 @@ def test_cftime_range( assert np.max(np.abs(deltas)) < 0.001 -def test_cftime_range_name(): - result = cftime_range(start="2000", periods=4, name="foo") +def test_date_range_name(): + result = date_range(start="2000", periods=4, name="foo") assert result.name == "foo" - result = cftime_range(start="2000", periods=4) + result = date_range(start="2000", periods=4) assert result.name is None @@ -1274,7 +1274,7 @@ def test_cftime_range_name(): ("2000", "2001", 5, "YE", None), ], ) -def test_invalid_cftime_range_inputs( +def test_invalid_date_range_cftime_inputs( start: str | None, end: str | None, periods: int | None, @@ -1282,7 +1282,7 @@ def test_invalid_cftime_range_inputs( inclusive: Literal["up", None], ) -> None: with pytest.raises(ValueError): - cftime_range(start, end, periods, freq, inclusive=inclusive) # type: ignore[arg-type] + date_range(start, end, periods, freq, inclusive=inclusive, use_cftime=True) # type: ignore[arg-type] _CALENDAR_SPECIFIC_MONTH_END_TESTS = [ @@ -1304,11 +1304,15 @@ def test_calendar_specific_month_end( calendar: str, expected_month_day: list[tuple[int, int]] ) -> None: year = 2000 # Use a leap-year to highlight calendar differences - result = cftime_range( - start="2000-02", end="2001", freq="2ME", calendar=calendar - ).values date_type = get_date_type(calendar) expected = [date_type(year, *args) for args in expected_month_day] + result = date_range( + start="2000-02", + end="2001", + freq="2ME", + calendar=calendar, + use_cftime=True, + ).values np.testing.assert_equal(result, expected) @@ -1321,14 +1325,11 @@ def test_calendar_specific_month_end_negative_freq( calendar: str, expected_month_day: list[tuple[int, int]] ) -> None: year = 2000 # Use a leap-year to highlight calendar differences - result = cftime_range( - start="2001", - end="2000", - freq="-2ME", - calendar=calendar, - ).values date_type = get_date_type(calendar) expected = [date_type(year, *args) for args in expected_month_day[::-1]] + result = date_range( + start="2001", end="2000", freq="-2ME", calendar=calendar, use_cftime=True + ).values np.testing.assert_equal(result, expected) @@ -1352,13 +1353,15 @@ def test_calendar_specific_month_end_negative_freq( def test_calendar_year_length( calendar: str, start: str, end: str, expected_number_of_days: int ) -> None: - result = cftime_range(start, end, freq="D", inclusive="left", calendar=calendar) + result = date_range( + start, end, freq="D", inclusive="left", calendar=calendar, use_cftime=True + ) assert len(result) == expected_number_of_days @pytest.mark.parametrize("freq", ["YE", "ME", "D"]) -def test_dayofweek_after_cftime_range(freq: str) -> None: - result = cftime_range("2000-02-01", periods=3, freq=freq).dayofweek +def test_dayofweek_after_cftime(freq: str) -> None: + result = date_range("2000-02-01", periods=3, freq=freq, use_cftime=True).dayofweek # TODO: remove once requiring pandas 2.2+ freq = _new_to_legacy_freq(freq) expected = pd.date_range("2000-02-01", periods=3, freq=freq).dayofweek @@ -1366,8 +1369,8 @@ def test_dayofweek_after_cftime_range(freq: str) -> None: @pytest.mark.parametrize("freq", ["YE", "ME", "D"]) -def test_dayofyear_after_cftime_range(freq: str) -> None: - result = cftime_range("2000-02-01", periods=3, freq=freq).dayofyear +def test_dayofyear_after_cftime(freq: str) -> None: + result = date_range("2000-02-01", periods=3, freq=freq, use_cftime=True).dayofyear # TODO: remove once requiring pandas 2.2+ freq = _new_to_legacy_freq(freq) expected = pd.date_range("2000-02-01", periods=3, freq=freq).dayofyear @@ -1377,7 +1380,7 @@ def test_dayofyear_after_cftime_range(freq: str) -> None: def test_cftime_range_standard_calendar_refers_to_gregorian() -> None: from cftime import DatetimeGregorian - (result,) = cftime_range("2000", periods=1) + (result,) = date_range("2000", periods=1, use_cftime=True) assert isinstance(result, DatetimeGregorian) @@ -1518,22 +1521,27 @@ def as_timedelta_not_implemented_error(): tick.as_timedelta() -@pytest.mark.parametrize("function", [cftime_range, date_range]) -def test_cftime_or_date_range_invalid_inclusive_value(function: Callable) -> None: - if function == cftime_range and not has_cftime: +@pytest.mark.parametrize("use_cftime", [True, False]) +def test_cftime_or_date_range_invalid_inclusive_value(use_cftime: bool) -> None: + if use_cftime and not has_cftime: pytest.skip("requires cftime") + if TYPE_CHECKING: + pytest.skip("inclusive type checked internally") + with pytest.raises(ValueError, match="nclusive"): - function("2000", periods=3, inclusive="foo") + date_range("2000", periods=3, inclusive="foo", use_cftime=use_cftime) -@pytest.mark.parametrize("function", [cftime_range, date_range]) -def test_cftime_or_date_range_inclusive_None(function) -> None: - if function == cftime_range and not has_cftime: +@pytest.mark.parametrize("use_cftime", [True, False]) +def test_cftime_or_date_range_inclusive_None(use_cftime: bool) -> None: + if use_cftime and not has_cftime: pytest.skip("requires cftime") - result_None = function("2000-01-01", "2000-01-04") - result_both = function("2000-01-01", "2000-01-04", inclusive="both") + result_None = date_range("2000-01-01", "2000-01-04", use_cftime=use_cftime) + result_both = date_range( + "2000-01-01", "2000-01-04", inclusive="both", use_cftime=use_cftime + ) np.testing.assert_equal(result_None.values, result_both.values) @@ -1690,11 +1698,11 @@ def test_cftime_range_same_as_pandas(start, end, freq) -> None: ) def test_cftime_range_no_freq(start, end, periods): """ - Test whether cftime_range produces the same result as Pandas + Test whether date_range produces the same result as Pandas when freq is not provided, but start, end and periods are. """ # Generate date ranges using cftime_range - cftimeindex = cftime_range(start=start, end=end, periods=periods) + cftimeindex = date_range(start=start, end=end, periods=periods, use_cftime=True) result = cftimeindex.to_datetimeindex(time_unit="ns") expected = pd.date_range(start=start, end=end, periods=periods) diff --git a/xarray/tests/test_cftimeindex.py b/xarray/tests/test_cftimeindex.py index 9531f3fbf0b..f37a243057b 100644 --- a/xarray/tests/test_cftimeindex.py +++ b/xarray/tests/test_cftimeindex.py @@ -819,7 +819,7 @@ def test_cftimeindex_add(index): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_add_timedeltaindex(calendar) -> None: - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) deltas = pd.TimedeltaIndex([timedelta(days=2) for _ in range(5)]) result = a + deltas expected = a.shift(2, "D") @@ -841,7 +841,7 @@ def test_cftimeindex_add_timedeltaindex(calendar) -> None: ) @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_shift_float(n, freq, units, calendar) -> None: - a = xr.cftime_range("2000", periods=3, calendar=calendar, freq="D") + a = xr.date_range("2000", periods=3, calendar=calendar, freq="D", use_cftime=True) result = a + pd.Timedelta(n, units) expected = a.shift(n, freq) assert result.equals(expected) @@ -850,7 +850,7 @@ def test_cftimeindex_shift_float(n, freq, units, calendar) -> None: @requires_cftime def test_cftimeindex_shift_float_us() -> None: - a = xr.cftime_range("2000", periods=3, freq="D") + a = xr.date_range("2000", periods=3, freq="D", use_cftime=True) with pytest.raises( ValueError, match="Could not convert to integer offset at any resolution" ): @@ -860,7 +860,7 @@ def test_cftimeindex_shift_float_us() -> None: @requires_cftime @pytest.mark.parametrize("freq", ["YS", "YE", "QS", "QE", "MS", "ME"]) def test_cftimeindex_shift_float_fails_for_non_tick_freqs(freq) -> None: - a = xr.cftime_range("2000", periods=3, freq="D") + a = xr.date_range("2000", periods=3, freq="D", use_cftime=True) with pytest.raises(TypeError, match="unsupported operand type"): a.shift(2.5, freq) @@ -883,7 +883,7 @@ def test_cftimeindex_radd(index): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_timedeltaindex_add_cftimeindex(calendar) -> None: - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) deltas = pd.TimedeltaIndex([timedelta(days=2) for _ in range(5)]) result = deltas + a expected = a.shift(2, "D") @@ -931,7 +931,7 @@ def test_cftimeindex_sub_timedelta_array(index, other): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_sub_cftimeindex(calendar) -> None: - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) b = a.shift(2, "D") result = b - a expected = pd.TimedeltaIndex([timedelta(days=2) for _ in range(5)]) @@ -942,7 +942,7 @@ def test_cftimeindex_sub_cftimeindex(calendar) -> None: @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_sub_cftime_datetime(calendar): - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) result = a - a[0] expected = pd.TimedeltaIndex([timedelta(days=i) for i in range(5)]) assert result.equals(expected) @@ -952,7 +952,7 @@ def test_cftimeindex_sub_cftime_datetime(calendar): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftime_datetime_sub_cftimeindex(calendar): - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) result = a[0] - a expected = pd.TimedeltaIndex([timedelta(days=-i) for i in range(5)]) assert result.equals(expected) @@ -962,7 +962,7 @@ def test_cftime_datetime_sub_cftimeindex(calendar): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_distant_cftime_datetime_sub_cftimeindex(calendar): - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) with pytest.raises(ValueError, match="difference exceeds"): a.date_type(1, 1, 1) - a @@ -970,7 +970,7 @@ def test_distant_cftime_datetime_sub_cftimeindex(calendar): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_sub_timedeltaindex(calendar) -> None: - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) deltas = pd.TimedeltaIndex([timedelta(days=2) for _ in range(5)]) result = a - deltas expected = a.shift(-2, "D") @@ -981,7 +981,7 @@ def test_cftimeindex_sub_timedeltaindex(calendar) -> None: @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_sub_index_of_cftime_datetimes(calendar): - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) b = pd.Index(a.values) expected = a - a result = a - b @@ -992,7 +992,7 @@ def test_cftimeindex_sub_index_of_cftime_datetimes(calendar): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_cftimeindex_sub_not_implemented(calendar): - a = xr.cftime_range("2000", periods=5, calendar=calendar) + a = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) with pytest.raises(TypeError, match="unsupported operand"): a - 1 @@ -1021,16 +1021,16 @@ def test_cftimeindex_shift(index, freq) -> None: @requires_cftime def test_cftimeindex_shift_invalid_periods() -> None: - index = xr.cftime_range("2000", periods=3) + index = xr.date_range("2000", periods=3, use_cftime=True) with pytest.raises(TypeError): - index.shift("a", "D") # type: ignore[arg-type] + index.shift("a", "D") @requires_cftime def test_cftimeindex_shift_invalid_freq() -> None: - index = xr.cftime_range("2000", periods=3) + index = xr.date_range("2000", periods=3, use_cftime=True) with pytest.raises(TypeError): - index.shift(1, 1) # type: ignore[arg-type] + index.shift(1, 1) @requires_cftime @@ -1047,7 +1047,7 @@ def test_cftimeindex_shift_invalid_freq() -> None: ], ) def test_cftimeindex_calendar_property(calendar, expected): - index = xr.cftime_range(start="2000", periods=3, calendar=calendar) + index = xr.date_range(start="2000", periods=3, calendar=calendar, use_cftime=True) assert index.calendar == expected @@ -1072,7 +1072,9 @@ def test_empty_cftimeindex_calendar_property(): ) def test_cftimeindex_freq_property_none_size_lt_3(calendar): for periods in range(3): - index = xr.cftime_range(start="2000", periods=periods, calendar=calendar) + index = xr.date_range( + start="2000", periods=periods, calendar=calendar, use_cftime=True + ) assert index.freq is None @@ -1091,7 +1093,7 @@ def test_cftimeindex_freq_property_none_size_lt_3(calendar): ) def test_cftimeindex_calendar_repr(calendar, expected): """Test that cftimeindex has calendar property in repr.""" - index = xr.cftime_range(start="2000", periods=3, calendar=calendar) + index = xr.date_range(start="2000", periods=3, calendar=calendar, use_cftime=True) repr_str = index.__repr__() assert f" calendar='{expected}'" in repr_str assert "2000-01-01 00:00:00, 2000-01-02 00:00:00" in repr_str @@ -1101,7 +1103,7 @@ def test_cftimeindex_calendar_repr(calendar, expected): @pytest.mark.parametrize("periods", [2, 40]) def test_cftimeindex_periods_repr(periods): """Test that cftimeindex has periods property in repr.""" - index = xr.cftime_range(start="2000", periods=periods) + index = xr.date_range(start="2000", periods=periods, use_cftime=True) repr_str = index.__repr__() assert f" length={periods}" in repr_str @@ -1111,7 +1113,9 @@ def test_cftimeindex_periods_repr(periods): @pytest.mark.parametrize("freq", ["D", "h"]) def test_cftimeindex_freq_in_repr(freq, calendar): """Test that cftimeindex has frequency property in repr.""" - index = xr.cftime_range(start="2000", periods=3, freq=freq, calendar=calendar) + index = xr.date_range( + start="2000", periods=3, freq=freq, calendar=calendar, use_cftime=True + ) repr_str = index.__repr__() assert f", freq='{freq}'" in repr_str @@ -1151,7 +1155,7 @@ def test_cftimeindex_freq_in_repr(freq, calendar): ) def test_cftimeindex_repr_formatting(periods, expected): """Test that cftimeindex.__repr__ is formatted similar to pd.Index.__repr__.""" - index = xr.cftime_range(start="2000", periods=periods, freq="D") + index = xr.date_range(start="2000", periods=periods, freq="D", use_cftime=True) expected = dedent(expected) assert expected == repr(index) @@ -1161,7 +1165,7 @@ def test_cftimeindex_repr_formatting(periods, expected): @pytest.mark.parametrize("periods", [2, 3, 4, 100, 101]) def test_cftimeindex_repr_formatting_width(periods, display_width): """Test that cftimeindex is sensitive to OPTIONS['display_width'].""" - index = xr.cftime_range(start="2000", periods=periods) + index = xr.date_range(start="2000", periods=periods, use_cftime=True) len_intro_str = len("CFTimeIndex(") with xr.set_options(display_width=display_width): repr_str = index.__repr__() @@ -1177,8 +1181,8 @@ def test_cftimeindex_repr_formatting_width(periods, display_width): @requires_cftime @pytest.mark.parametrize("periods", [22, 50, 100]) def test_cftimeindex_repr_101_shorter(periods): - index_101 = xr.cftime_range(start="2000", periods=101) - index_periods = xr.cftime_range(start="2000", periods=periods) + index_101 = xr.date_range(start="2000", periods=101, use_cftime=True) + index_periods = xr.date_range(start="2000", periods=periods, use_cftime=True) index_101_repr_str = index_101.__repr__() index_periods_repr_str = index_periods.__repr__() assert len(index_101_repr_str) < len(index_periods_repr_str) @@ -1210,7 +1214,7 @@ def test_parse_array_of_cftime_strings(): @pytest.mark.parametrize("calendar", _ALL_CALENDARS) def test_strftime_of_cftime_array(calendar): date_format = "%Y%m%d%H%M" - cf_values = xr.cftime_range("2000", periods=5, calendar=calendar) + cf_values = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) dt_values = pd.date_range("2000", periods=5) expected = pd.Index(dt_values.strftime(date_format)) result = cf_values.strftime(date_format) @@ -1221,7 +1225,7 @@ def test_strftime_of_cftime_array(calendar): @pytest.mark.parametrize("calendar", _ALL_CALENDARS) @pytest.mark.parametrize("unsafe", [False, True]) def test_to_datetimeindex(calendar, unsafe) -> None: - index = xr.cftime_range("2000", periods=5, calendar=calendar) + index = xr.date_range("2000", periods=5, calendar=calendar, use_cftime=True) expected = pd.date_range("2000", periods=5, unit="ns") if calendar in _NON_STANDARD_CALENDARS and not unsafe: @@ -1237,7 +1241,7 @@ def test_to_datetimeindex(calendar, unsafe) -> None: @requires_cftime def test_to_datetimeindex_future_warning() -> None: - index = xr.cftime_range("2000", periods=5) + index = xr.date_range("2000", periods=5, use_cftime=True) expected = pd.date_range("2000", periods=5, unit="ns") with pytest.warns(FutureWarning, match="In a future version"): result = index.to_datetimeindex() @@ -1248,7 +1252,7 @@ def test_to_datetimeindex_future_warning() -> None: @requires_cftime @pytest.mark.parametrize("calendar", _ALL_CALENDARS) def test_to_datetimeindex_out_of_range(calendar) -> None: - index = xr.cftime_range("0001", periods=5, calendar=calendar) + index = xr.date_range("0001", periods=5, calendar=calendar, use_cftime=True) with pytest.raises(ValueError, match="0001"): index.to_datetimeindex(time_unit="ns") @@ -1256,7 +1260,7 @@ def test_to_datetimeindex_out_of_range(calendar) -> None: @requires_cftime @pytest.mark.parametrize("unsafe", [False, True]) def test_to_datetimeindex_gregorian_pre_reform(unsafe) -> None: - index = xr.cftime_range("1582", periods=5, calendar="gregorian") + index = xr.date_range("1582", periods=5, calendar="gregorian", use_cftime=True) if unsafe: result = index.to_datetimeindex(time_unit="us", unsafe=unsafe) else: @@ -1270,7 +1274,7 @@ def test_to_datetimeindex_gregorian_pre_reform(unsafe) -> None: @requires_cftime @pytest.mark.parametrize("calendar", ["all_leap", "360_day"]) def test_to_datetimeindex_feb_29(calendar) -> None: - index = xr.cftime_range("2001-02-28", periods=2, calendar=calendar) + index = xr.date_range("2001-02-28", periods=2, calendar=calendar, use_cftime=True) with pytest.raises(ValueError, match="29"): index.to_datetimeindex(time_unit="ns") @@ -1278,7 +1282,9 @@ def test_to_datetimeindex_feb_29(calendar) -> None: @pytest.mark.xfail(reason="fails on pandas main branch") @requires_cftime def test_multiindex(): - index = xr.cftime_range("2001-01-01", periods=100, calendar="360_day") + index = xr.date_range( + "2001-01-01", periods=100, calendar="360_day", use_cftime=True + ) mindex = pd.MultiIndex.from_arrays([index]) assert mindex.get_loc("2001-01") == slice(0, 30) @@ -1290,7 +1296,9 @@ def test_rounding_methods_against_datetimeindex(freq, method) -> None: # for now unit="us" seems good enough expected = pd.date_range("2000-01-02T01:03:51", periods=10, freq="1777s", unit="ns") expected = getattr(expected, method)(freq) - result = xr.cftime_range("2000-01-02T01:03:51", periods=10, freq="1777s") + result = xr.date_range( + "2000-01-02T01:03:51", periods=10, freq="1777s", use_cftime=True + ) result = getattr(result, method)(freq).to_datetimeindex(time_unit="ns") assert result.equals(expected) @@ -1310,7 +1318,9 @@ def test_rounding_methods_empty_cftimindex(method): @requires_cftime @pytest.mark.parametrize("method", ["floor", "ceil", "round"]) def test_rounding_methods_invalid_freq(method): - index = xr.cftime_range("2000-01-02T01:03:51", periods=10, freq="1777s") + index = xr.date_range( + "2000-01-02T01:03:51", periods=10, freq="1777s", use_cftime=True + ) with pytest.raises(ValueError, match="fixed"): getattr(index, method)("MS") @@ -1395,7 +1405,7 @@ def test_asi8_empty_cftimeindex(): @requires_cftime def test_infer_freq_valid_types(time_unit: PDDatetimeUnitOptions) -> None: - cf_indx = xr.cftime_range("2000-01-01", periods=3, freq="D") + cf_indx = xr.date_range("2000-01-01", periods=3, freq="D", use_cftime=True) assert xr.infer_freq(cf_indx) == "D" assert xr.infer_freq(xr.DataArray(cf_indx)) == "D" @@ -1414,7 +1424,7 @@ def test_infer_freq_invalid_inputs(): with pytest.raises(ValueError, match="must contain datetime-like objects"): xr.infer_freq(xr.DataArray([0, 1, 2])) - indx = xr.cftime_range("1990-02-03", periods=4, freq="MS") + indx = xr.date_range("1990-02-03", periods=4, freq="MS", use_cftime=True) # 2D DataArray with pytest.raises(ValueError, match="must be 1D"): xr.infer_freq(xr.DataArray([indx, indx])) @@ -1433,7 +1443,7 @@ def test_infer_freq_invalid_inputs(): assert xr.infer_freq(indx[np.array([0, 1, 3])]) is None # Same, but for QS - indx = xr.cftime_range("1990-02-03", periods=4, freq="QS") + indx = xr.date_range("1990-02-03", periods=4, freq="QS", use_cftime=True) assert xr.infer_freq(indx[np.array([0, 1, 3])]) is None @@ -1458,7 +1468,9 @@ def test_infer_freq_invalid_inputs(): ) @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_infer_freq(freq, calendar): - indx = xr.cftime_range("2000-01-01", periods=3, freq=freq, calendar=calendar) + indx = xr.date_range( + "2000-01-01", periods=3, freq=freq, calendar=calendar, use_cftime=True + ) out = xr.infer_freq(indx) assert out == freq @@ -1466,6 +1478,8 @@ def test_infer_freq(freq, calendar): @requires_cftime @pytest.mark.parametrize("calendar", _CFTIME_CALENDARS) def test_pickle_cftimeindex(calendar): - idx = xr.cftime_range("2000-01-01", periods=3, freq="D", calendar=calendar) + idx = xr.date_range( + "2000-01-01", periods=3, freq="D", calendar=calendar, use_cftime=True + ) idx_pkl = pickle.loads(pickle.dumps(idx)) assert (idx == idx_pkl).all() diff --git a/xarray/tests/test_cftimeindex_resample.py b/xarray/tests/test_cftimeindex_resample.py index 5510eaacf1f..fa896da0ed6 100644 --- a/xarray/tests/test_cftimeindex_resample.py +++ b/xarray/tests/test_cftimeindex_resample.py @@ -132,7 +132,9 @@ def test_resample(freqs, closed, label, offset) -> None: datetime_index = pd.date_range( start=start, periods=5, freq=_new_to_legacy_freq(initial_freq) ) - cftime_index = xr.cftime_range(start=start, periods=5, freq=initial_freq) + cftime_index = xr.date_range( + start=start, periods=5, freq=initial_freq, use_cftime=True + ) da_datetimeindex = da(datetime_index) da_cftimeindex = da(cftime_index) @@ -174,8 +176,12 @@ def test_closed_label_defaults(freq, expected) -> None: def test_calendars(calendar: str) -> None: # Limited testing for non-standard calendars freq, closed, label = "8001min", None, None - xr_index = xr.cftime_range( - start="2004-01-01T12:07:01", periods=7, freq="3D", calendar=calendar + xr_index = xr.date_range( + start="2004-01-01T12:07:01", + periods=7, + freq="3D", + calendar=calendar, + use_cftime=True, ) pd_index = pd.date_range(start="2004-01-01T12:07:01", periods=7, freq="3D") da_cftime = da(xr_index).resample(time=freq, closed=closed, label=label).mean() @@ -204,7 +210,7 @@ def test_origin(closed, origin) -> None: start = "1969-12-31T12:07:01" index_kwargs: DateRangeKwargs = dict(start=start, periods=12, freq=initial_freq) datetime_index = pd.date_range(**index_kwargs) - cftime_index = xr.cftime_range(**index_kwargs) + cftime_index = xr.date_range(**index_kwargs, use_cftime=True) da_datetimeindex = da(datetime_index) da_cftimeindex = da(cftime_index) @@ -219,7 +225,7 @@ def test_origin(closed, origin) -> None: @pytest.mark.parametrize("offset", ["foo", "5MS", 10]) def test_invalid_offset_error(offset: str | int) -> None: - cftime_index = xr.cftime_range("2000", periods=5) + cftime_index = xr.date_range("2000", periods=5, use_cftime=True) da_cftime = da(cftime_index) with pytest.raises(ValueError, match="offset must be"): da_cftime.resample(time="2D", offset=offset) # type: ignore[arg-type] @@ -229,7 +235,7 @@ def test_timedelta_offset() -> None: timedelta = datetime.timedelta(seconds=5) string = "5s" - cftime_index = xr.cftime_range("2000", periods=5) + cftime_index = xr.date_range("2000", periods=5, use_cftime=True) da_cftime = da(cftime_index) timedelta_result = da_cftime.resample(time="2D", offset=timedelta).mean() diff --git a/xarray/tests/test_coarsen.py b/xarray/tests/test_coarsen.py index ab04a7b3cde..8faa839d874 100644 --- a/xarray/tests/test_coarsen.py +++ b/xarray/tests/test_coarsen.py @@ -68,10 +68,10 @@ def test_coarsen_coords(ds, dask): @requires_cftime def test_coarsen_coords_cftime(): - times = xr.cftime_range("2000", periods=6) + times = xr.date_range("2000", periods=6, use_cftime=True) da = xr.DataArray(range(6), [("time", times)]) actual = da.coarsen(time=3).mean() - expected_times = xr.cftime_range("2000-01-02", freq="3D", periods=2) + expected_times = xr.date_range("2000-01-02", freq="3D", periods=2, use_cftime=True) np.testing.assert_array_equal(actual.time, expected_times) diff --git a/xarray/tests/test_coding_times.py b/xarray/tests/test_coding_times.py index 2e61e5d853e..1bc0037decc 100644 --- a/xarray/tests/test_coding_times.py +++ b/xarray/tests/test_coding_times.py @@ -14,7 +14,6 @@ DataArray, Dataset, Variable, - cftime_range, conventions, date_range, decode_cf, @@ -1086,15 +1085,15 @@ def test_decode_ambiguous_time_warns(calendar) -> None: @pytest.mark.filterwarnings("ignore:Times can't be serialized faithfully") @pytest.mark.parametrize("encoding_units", FREQUENCIES_TO_ENCODING_UNITS.values()) @pytest.mark.parametrize("freq", FREQUENCIES_TO_ENCODING_UNITS.keys()) -@pytest.mark.parametrize("date_range", [pd.date_range, cftime_range]) +@pytest.mark.parametrize("use_cftime", [True, False]) def test_encode_cf_datetime_defaults_to_correct_dtype( - encoding_units, freq, date_range + encoding_units, freq, use_cftime ) -> None: - if not has_cftime and date_range == cftime_range: + if not has_cftime and use_cftime: pytest.skip("Test requires cftime") - if (freq == "ns" or encoding_units == "nanoseconds") and date_range == cftime_range: + if (freq == "ns" or encoding_units == "nanoseconds") and use_cftime: pytest.skip("Nanosecond frequency is not valid for cftime dates.") - times = date_range("2000", periods=3, freq=freq) + times = date_range("2000", periods=3, freq=freq, use_cftime=use_cftime) units = f"{encoding_units} since 2000-01-01" encoded, _units, _ = encode_cf_datetime(times, units) @@ -1125,9 +1124,10 @@ def test_encode_decode_roundtrip_datetime64( @requires_cftime @pytest.mark.parametrize("freq", ["us", "ms", "s", "min", "h", "D"]) def test_encode_decode_roundtrip_cftime(freq) -> None: - initial_time = cftime_range("0001", periods=1) + initial_time = date_range("0001", periods=1, use_cftime=True) times = initial_time.append( - cftime_range("0001", periods=2, freq=freq) + timedelta(days=291000 * 365) + date_range("0001", periods=2, freq=freq, use_cftime=True) + + timedelta(days=291000 * 365) ) variable = Variable(["time"], times) encoded = conventions.encode_cf_variable(variable) @@ -1208,7 +1208,9 @@ def test_decode_encode_roundtrip_with_non_lowercase_letters( @requires_cftime def test_should_cftime_be_used_source_outside_range(): - src = cftime_range("1000-01-01", periods=100, freq="MS", calendar="noleap") + src = date_range( + "1000-01-01", periods=100, freq="MS", calendar="noleap", use_cftime=True + ) with pytest.raises( ValueError, match="Source time range is not valid for numpy datetimes." ): @@ -1217,7 +1219,9 @@ def test_should_cftime_be_used_source_outside_range(): @requires_cftime def test_should_cftime_be_used_target_not_npable(): - src = cftime_range("2000-01-01", periods=100, freq="MS", calendar="noleap") + src = date_range( + "2000-01-01", periods=100, freq="MS", calendar="noleap", use_cftime=True + ) with pytest.raises( ValueError, match="Calendar 'noleap' is only valid with cftime." ): @@ -1678,7 +1682,9 @@ def test_encode_cf_datetime_cftime_datetime_via_dask(units, dtype) -> None: import dask.array calendar = "standard" - times_idx = cftime_range(start="1700", freq="D", periods=3, calendar=calendar) + times_idx = date_range( + start="1700", freq="D", periods=3, calendar=calendar, use_cftime=True + ) times = dask.array.from_array(times_idx, chunks=1) encoded_times, encoding_units, encoding_calendar = encode_cf_datetime( times, units, None, dtype diff --git a/xarray/tests/test_conventions.py b/xarray/tests/test_conventions.py index 8d3827fac54..1d3a8bc809d 100644 --- a/xarray/tests/test_conventions.py +++ b/xarray/tests/test_conventions.py @@ -11,9 +11,9 @@ Dataset, SerializationWarning, Variable, - cftime_range, coding, conventions, + date_range, open_dataset, ) from xarray.backends.common import WritableCFDataStore @@ -624,7 +624,7 @@ def test_decode_cf_variable_datetime64(): @requires_cftime def test_decode_cf_variable_cftime(): - variable = Variable(["time"], cftime_range("2000", periods=2)) + variable = Variable(["time"], date_range("2000", periods=2, use_cftime=True)) decoded = conventions.decode_cf_variable("time", variable) assert decoded.encoding == {} assert_identical(decoded, variable) diff --git a/xarray/tests/test_dataset.py b/xarray/tests/test_dataset.py index 7be2d13f9dd..5ef6b459ceb 100644 --- a/xarray/tests/test_dataset.py +++ b/xarray/tests/test_dataset.py @@ -3256,7 +3256,9 @@ def test_rename_preserve_attrs_encoding(self) -> None: def test_rename_does_not_change_CFTimeIndex_type(self) -> None: # make sure CFTimeIndex is not converted to DatetimeIndex #3522 - time = xr.cftime_range(start="2000", periods=6, freq="2MS", calendar="noleap") + time = xr.date_range( + start="2000", periods=6, freq="2MS", calendar="noleap", use_cftime=True + ) orig = Dataset(coords={"time": time}) renamed = orig.rename(time="time_new") @@ -7299,7 +7301,7 @@ def test_differentiate_datetime(dask) -> None: @pytest.mark.parametrize("dask", [True, False]) def test_differentiate_cftime(dask) -> None: rs = np.random.default_rng(42) - coord = xr.cftime_range("2000", periods=8, freq="2ME") + coord = xr.date_range("2000", periods=8, freq="2ME", use_cftime=True) da = xr.DataArray( rs.random((8, 6)), @@ -7462,7 +7464,7 @@ def test_trapezoid_datetime(dask, which_datetime) -> None: else: if not has_cftime: pytest.skip("Test requires cftime.") - coord = xr.cftime_range("2000", periods=8, freq="2D") + coord = xr.date_range("2000", periods=8, freq="2D", use_cftime=True) da = xr.DataArray( rs.random((8, 6)), diff --git a/xarray/tests/test_distributed.py b/xarray/tests/test_distributed.py index e4fdf08d0b4..a2021e30e0f 100644 --- a/xarray/tests/test_distributed.py +++ b/xarray/tests/test_distributed.py @@ -132,7 +132,7 @@ def test_dask_distributed_write_netcdf_with_dimensionless_variables( @requires_netCDF4 @pytest.mark.parametrize("parallel", (True, False)) def test_open_mfdataset_can_open_files_with_cftime_index(parallel, tmp_path): - T = xr.cftime_range("20010101", "20010501", calendar="360_day") + T = xr.date_range("20010101", "20010501", calendar="360_day", use_cftime=True) Lon = np.arange(100) data = np.random.random((T.size, Lon.size)) da = xr.DataArray(data, coords={"time": T, "Lon": Lon}, name="test") @@ -149,7 +149,7 @@ def test_open_mfdataset_can_open_files_with_cftime_index(parallel, tmp_path): @pytest.mark.parametrize("parallel", (True, False)) def test_open_mfdataset_multiple_files_parallel_distributed(parallel, tmp_path): lon = np.arange(100) - time = xr.cftime_range("20010101", periods=100, calendar="360_day") + time = xr.date_range("20010101", periods=100, calendar="360_day", use_cftime=True) data = np.random.random((time.size, lon.size)) da = xr.DataArray(data, coords={"time": time, "lon": lon}, name="test") @@ -177,7 +177,7 @@ def test_open_mfdataset_multiple_files_parallel(parallel, tmp_path): "Flaky in CI. Would be a welcome contribution to make a similar test reliable." ) lon = np.arange(100) - time = xr.cftime_range("20010101", periods=100, calendar="360_day") + time = xr.date_range("20010101", periods=100, calendar="360_day", use_cftime=True) data = np.random.random((time.size, lon.size)) da = xr.DataArray(data, coords={"time": time, "lon": lon}, name="test") diff --git a/xarray/tests/test_duck_array_ops.py b/xarray/tests/test_duck_array_ops.py index 1f4ef2acf91..c0ecfe638dc 100644 --- a/xarray/tests/test_duck_array_ops.py +++ b/xarray/tests/test_duck_array_ops.py @@ -8,7 +8,7 @@ import pytest from numpy import array, nan -from xarray import DataArray, Dataset, cftime_range, concat +from xarray import DataArray, Dataset, concat, date_range from xarray.coding.times import _NS_PER_TIME_DELTA from xarray.core import dtypes, duck_array_ops from xarray.core.duck_array_ops import ( @@ -454,7 +454,7 @@ def test_cftime_datetime_mean(dask): if dask and not has_dask: pytest.skip("requires dask") - times = cftime_range("2000", periods=4) + times = date_range("2000", periods=4, use_cftime=True) da = DataArray(times, dims=["time"]) da_2d = DataArray(times.values.reshape(2, 2)) @@ -501,7 +501,10 @@ def test_mean_over_non_time_dim_of_dataset_with_dask_backed_cftime_data(): # dimension still fails if the time variable is dask-backed. ds = Dataset( { - "var1": (("time",), cftime_range("2021-10-31", periods=10, freq="D")), + "var1": ( + ("time",), + date_range("2021-10-31", periods=10, freq="D", use_cftime=True), + ), "var2": (("x",), list(range(10))), } ) @@ -900,7 +903,9 @@ def test_datetime_to_numeric_cftime(dask): if dask and not has_dask: pytest.skip("requires dask") - times = cftime_range("2000", periods=5, freq="7D", calendar="standard").values + times = date_range( + "2000", periods=5, freq="7D", calendar="standard", use_cftime=True + ).values if dask: import dask.array @@ -946,8 +951,8 @@ def test_datetime_to_numeric_potential_overflow(time_unit: PDDatetimeUnitOptions pytest.skip("out-of-bounds datetime64 overflow") dtype = f"M8[{time_unit}]" times = pd.date_range("2000", periods=5, freq="7D").values.astype(dtype) - cftimes = cftime_range( - "2000", periods=5, freq="7D", calendar="proleptic_gregorian" + cftimes = date_range( + "2000", periods=5, freq="7D", calendar="proleptic_gregorian", use_cftime=True ).values offset = np.datetime64("0001-01-01", time_unit) diff --git a/xarray/tests/test_interp.py b/xarray/tests/test_interp.py index b2171f31c33..df265029250 100644 --- a/xarray/tests/test_interp.py +++ b/xarray/tests/test_interp.py @@ -751,10 +751,12 @@ def test_datetime_single_string() -> None: @requires_cftime @requires_scipy def test_cftime() -> None: - times = xr.cftime_range("2000", periods=24, freq="D") + times = xr.date_range("2000", periods=24, freq="D", use_cftime=True) da = xr.DataArray(np.arange(24), coords=[times], dims="time") - times_new = xr.cftime_range("2000-01-01T12:00:00", periods=3, freq="D") + times_new = xr.date_range( + "2000-01-01T12:00:00", periods=3, freq="D", use_cftime=True + ) actual = da.interp(time=times_new) expected = xr.DataArray([0.5, 1.5, 2.5], coords=[times_new], dims=["time"]) @@ -764,11 +766,11 @@ def test_cftime() -> None: @requires_cftime @requires_scipy def test_cftime_type_error() -> None: - times = xr.cftime_range("2000", periods=24, freq="D") + times = xr.date_range("2000", periods=24, freq="D", use_cftime=True) da = xr.DataArray(np.arange(24), coords=[times], dims="time") - times_new = xr.cftime_range( - "2000-01-01T12:00:00", periods=3, freq="D", calendar="noleap" + times_new = xr.date_range( + "2000-01-01T12:00:00", periods=3, freq="D", calendar="noleap", use_cftime=True ) with pytest.raises(TypeError): da.interp(time=times_new) @@ -779,8 +781,8 @@ def test_cftime_type_error() -> None: def test_cftime_list_of_strings() -> None: from cftime import DatetimeProlepticGregorian - times = xr.cftime_range( - "2000", periods=24, freq="D", calendar="proleptic_gregorian" + times = xr.date_range( + "2000", periods=24, freq="D", calendar="proleptic_gregorian", use_cftime=True ) da = xr.DataArray(np.arange(24), coords=[times], dims="time") @@ -800,8 +802,8 @@ def test_cftime_list_of_strings() -> None: def test_cftime_single_string() -> None: from cftime import DatetimeProlepticGregorian - times = xr.cftime_range( - "2000", periods=24, freq="D", calendar="proleptic_gregorian" + times = xr.date_range( + "2000", periods=24, freq="D", calendar="proleptic_gregorian", use_cftime=True ) da = xr.DataArray(np.arange(24), coords=[times], dims="time") @@ -830,7 +832,7 @@ def test_datetime_to_non_datetime_error() -> None: @requires_cftime @requires_scipy def test_cftime_to_non_cftime_error() -> None: - times = xr.cftime_range("2000", periods=24, freq="D") + times = xr.date_range("2000", periods=24, freq="D", use_cftime=True) da = xr.DataArray(np.arange(24), coords=[times], dims="time") with pytest.raises(TypeError): @@ -859,7 +861,7 @@ def test_datetime_interp_noerror() -> None: @requires_cftime @requires_scipy def test_3641() -> None: - times = xr.cftime_range("0001", periods=3, freq="500YE") + times = xr.date_range("0001", periods=3, freq="500YE", use_cftime=True) da = xr.DataArray(range(3), dims=["time"], coords=[times]) da.interp(time=["0002-05-01"]) diff --git a/xarray/tests/test_missing.py b/xarray/tests/test_missing.py index d3eaa70f1df..1f9d94868eb 100644 --- a/xarray/tests/test_missing.py +++ b/xarray/tests/test_missing.py @@ -40,8 +40,12 @@ def da(): @pytest.fixture def cf_da(): def _cf_da(calendar, freq="1D"): - times = xr.cftime_range( - start="1970-01-01", freq=freq, periods=10, calendar=calendar + times = xr.date_range( + start="1970-01-01", + freq=freq, + periods=10, + calendar=calendar, + use_cftime=True, ) values = np.arange(10) return xr.DataArray(values, dims=("time",), coords={"time": times}) @@ -623,7 +627,11 @@ def test_get_clean_interp_index_potential_overflow(): da = xr.DataArray( [0, 1, 2], dims=("time",), - coords={"time": xr.cftime_range("0000-01-01", periods=3, calendar="360_day")}, + coords={ + "time": xr.date_range( + "0000-01-01", periods=3, calendar="360_day", use_cftime=True + ) + }, ) get_clean_interp_index(da, "time") @@ -670,17 +678,17 @@ def test_interpolate_na_max_gap_errors(da_time): @requires_bottleneck @pytest.mark.parametrize( - "time_range_func", - [pd.date_range, pytest.param(xr.cftime_range, marks=requires_cftime)], + "use_cftime", + [False, pytest.param(True, marks=requires_cftime)], ) @pytest.mark.parametrize("transform", [lambda x: x, lambda x: x.to_dataset(name="a")]) @pytest.mark.parametrize( "max_gap", ["3h", np.timedelta64(3, "h"), pd.to_timedelta("3h")] ) -def test_interpolate_na_max_gap_time_specifier( - da_time, max_gap, transform, time_range_func -): - da_time["t"] = time_range_func("2001-01-01", freq="h", periods=11) +def test_interpolate_na_max_gap_time_specifier(da_time, max_gap, transform, use_cftime): + da_time["t"] = xr.date_range( + "2001-01-01", freq="h", periods=11, use_cftime=use_cftime + ) expected = transform( da_time.copy(data=[np.nan, 1, 2, 3, 4, 5, np.nan, np.nan, np.nan, np.nan, 10]) ) diff --git a/xarray/tests/test_plot.py b/xarray/tests/test_plot.py index 0a05451cb85..b9adda5b52d 100644 --- a/xarray/tests/test_plot.py +++ b/xarray/tests/test_plot.py @@ -2994,7 +2994,9 @@ def setUp(self) -> None: """ # case for 1d array data = np.random.rand(4, 12) - time = xr.cftime_range(start="2017", periods=12, freq="1ME", calendar="noleap") + time = xr.date_range( + start="2017", periods=12, freq="1ME", calendar="noleap", use_cftime=True + ) darray = DataArray(data, dims=["x", "time"]) darray.coords["time"] = time @@ -3022,8 +3024,8 @@ def setUp(self) -> None: month = np.arange(1, 13, 1) data = np.sin(2 * np.pi * month / 12.0) darray = DataArray(data, dims=["time"]) - darray.coords["time"] = xr.cftime_range( - start="2017", periods=12, freq="1ME", calendar="noleap" + darray.coords["time"] = xr.date_range( + start="2017", periods=12, freq="1ME", calendar="noleap", use_cftime=True ) self.darray = darray diff --git a/xarray/tests/test_weighted.py b/xarray/tests/test_weighted.py index 93a200c07a6..e9be98ab76b 100644 --- a/xarray/tests/test_weighted.py +++ b/xarray/tests/test_weighted.py @@ -67,7 +67,7 @@ def mean_func(ds): return ds.weighted(ds.weights).mean("time") # example dataset - t = xr.cftime_range(start="2000", periods=20, freq="1YS") + t = xr.date_range(start="2000", periods=20, freq="1YS", use_cftime=True) weights = xr.DataArray(np.random.rand(len(t)), dims=["time"], coords={"time": t}) data = xr.DataArray( np.random.rand(len(t)), dims=["time"], coords={"time": t, "weights": weights}