From 685e59885718c11e371136c37bc4aa0d208dc9b2 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Mon, 25 May 2020 16:41:42 -0400
Subject: [PATCH 01/19] Add num2date_exact function to decode times using
 timedelta addition

---
 cftime/__init__.py  |   2 +-
 cftime/_cftime.pyx  | 143 ++++++++++++++++++++++++++
 test/test_cftime.py | 239 +++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 381 insertions(+), 3 deletions(-)

diff --git a/cftime/__init__.py b/cftime/__init__.py
index 835aee08..82a4a228 100644
--- a/cftime/__init__.py
+++ b/cftime/__init__.py
@@ -5,5 +5,5 @@
                          DatetimeGregorian, DatetimeProlepticGregorian
 from ._cftime import microsec_units, millisec_units, \
                          sec_units, hr_units, day_units, min_units
-from ._cftime import num2date, date2num, date2index, num2pydate
+from ._cftime import num2date, date2num, date2index, num2pydate, num2date_exact
 from ._cftime import __version__
diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index cb45e0a6..3e97449e 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -7,12 +7,15 @@ from cpython.object cimport (PyObject_RichCompare, Py_LT, Py_LE, Py_EQ,
 from numpy cimport int64_t, int32_t
 import cython
 import numpy as np
+cimport numpy as np
+cimport cpython.datetime
 import re
 import sys
 import time
 from datetime import datetime as datetime_python
 from datetime import timedelta, MINYEAR
 import time                     # strftime
+import warnings
 try:
     from itertools import izip as zip
 except ImportError:  # python 3.x
@@ -396,6 +399,146 @@ OverflowError in python datetime, probably because year < datetime.MINYEAR"""
         return cdftime.num2date(times)
 
 
+UNIT_CONVERSION_FACTORS = {
+    "microseconds": 1,
+    "microsecond": 1,
+    "microsec": 1,
+    "microsecs": 1,
+    "milliseconds": 1000,
+    "millisecond": 1000,
+    "millisec": 1000,
+    "millisecs": 1000,
+    "msec": 1000,
+    "msecs": 1000,
+    "ms": 1000,
+    "seconds": 1000000,
+    "second": 1000000,
+    "sec": 1000000,
+    "secs": 1000000,
+    "s": 1000000,
+    "minutes": 60 * 1000000,
+    "minute": 60 * 1000000,
+    "min": 60 * 1000000,
+    "mins": 60 * 1000000,
+    "hours": 3600 * 1000000,
+    "hour": 3600 * 1000000,
+    "hr": 3600 * 1000000,
+    "hrs": 3600 * 1000000,
+    "h": 3600 * 1000000,
+    "day": 86400 * 1000000,
+    "days": 86400 * 1000000,
+    "d": 86400 * 1000000,
+    "month": 30 * 86400 * 1000000,  # Only allowed for 360_day calendar
+    "months": 30 * 86400 * 1000000
+}
+
+
+DATE_TYPES = {
+    "proleptic_gregorian": DatetimeProlepticGregorian,
+    "standard": DatetimeGregorian,
+    "noleap": DatetimeNoLeap,
+    "365_day": DatetimeNoLeap,
+    "all_leap": DatetimeAllLeap,
+    "366_day": DatetimeAllLeap,
+    "julian": DatetimeJulian,
+    "360_day": Datetime360Day,
+    "gregorian": DatetimeGregorian
+}
+
+
+def to_calendar_specific_datetime(datetime, calendar):
+    return DATE_TYPES[calendar](
+        datetime.year,
+        datetime.month,
+        datetime.day,
+        datetime.hour,
+        datetime.minute,
+        datetime.second,
+        datetime.microsecond
+    )
+
+
+def cast_to_int_if_safe(num):
+    """Copied from xarray.coding.times.py"""
+    if isinstance(num, np.ma.core.MaskedArray):
+        int_num = np.ma.masked_array(num, dtype=np.int64)
+    else:
+        int_num = np.array(num, dtype=np.int64)
+    if (num == int_num).all():
+        num = int_num
+    return num
+
+
+def num2date_exact(
+    times,
+    units,
+    calendar='standard',
+    only_use_cftime_datetimes=True,
+    only_use_python_datetimes=False
+):
+    """Decode times exactly with timedelta arithmetic."""
+    calendar = calendar.lower()
+    basedate = _dateparse(units)
+
+    can_use_python_datetime=\
+      ((calendar == 'proleptic_gregorian' and basedate.year >= MINYEAR) or \
+       (calendar in ['gregorian','standard'] and basedate > gregorian))
+    if not only_use_cftime_datetimes and only_use_python_datetimes:
+        if not can_use_python_datetime:
+            msg='illegal calendar or reference date for python datetime'
+            raise ValueError(msg)
+
+    unit, ignore = _datesplit(units)
+
+    # real-world calendars limited to positive reference years.
+    if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
+        if basedate.year == 0:
+            msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
+            raise ValueError(msg)
+
+    use_python_datetime = False
+    if only_use_python_datetimes and not only_use_cftime_datetimes:
+        # only_use_cftime_datetimes takes precendence
+        use_python_datetime = True
+    if not only_use_python_datetimes and not only_use_cftime_datetimes and can_use_python_datetime:
+        # if only_use_cftimes_datetimes and only_use_python_datetimes are False
+        # return python datetime if possible.
+        use_python_datetime = True
+
+    if use_python_datetime:
+        basedate = datetime_python(
+            basedate.year,
+            basedate.month,
+            basedate.day,
+            basedate.hour,
+            basedate.minute,
+            basedate.second,
+            basedate.microsecond
+        )
+    else:
+        basedate = to_calendar_specific_datetime(basedate, calendar)
+
+    if unit not in UNIT_CONVERSION_FACTORS:
+        raise ValueError("Invalid units provided.")
+
+    if unit in ["months", "month"] and calendar != "360_day":
+        raise ValueError("Units of months only valid for 360_day calendar.")
+
+    factor = UNIT_CONVERSION_FACTORS[unit]
+    scaled_times = factor * times
+
+    scaled_times = cast_to_int_if_safe(scaled_times)
+    if not np.issubdtype(scaled_times.dtype, np.integer):
+        warnings.warn(
+            "times must have integer dtype or be able to be safely cast to an "
+            "integer dtype to be decoded exactly.  Falling back to the "
+            "inexact version of the num2date function.")
+        return num2date(times, units, calendar, only_use_cftime_datetimes, only_use_python_datetimes)
+
+    shape = scaled_times.shape
+    deltas = scaled_times.astype("timedelta64[us]").astype(timedelta)
+    return basedate + deltas
+
 
 def date2index(dates, nctime, calendar=None, select='exact'):
     """date2index(dates, nctime, calendar=None, select='exact')
diff --git a/test/test_cftime.py b/test/test_cftime.py
index bcd69ce5..67b5d81b 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -5,7 +5,7 @@
 import sys
 import unittest
 from collections import namedtuple
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, MINYEAR
 
 import numpy as np
 import pytest
@@ -17,7 +17,7 @@
 from cftime import (DateFromJulianDay, Datetime360Day, DatetimeAllLeap,
                     DatetimeGregorian, DatetimeJulian, DatetimeNoLeap,
                     DatetimeProlepticGregorian, JulianDayFromDate, _parse_date,
-                    date2index, date2num, num2date, utime)
+                    date2index, date2num, num2date, utime, num2date_exact)
 
 try:
     from datetime import timezone
@@ -1555,5 +1555,240 @@ def test_dayofyr_after_timedelta_addition(date_type):
     assert date_after_timedelta_addition.dayofyr == 3
 
 
+_SHAPES = [(4, ), (2, 2)]
+_MICROSECOND_UNITS = ["microseconds", "microsecond", "microsec", "microsecs"]
+_MILLISECOND_UNITS = ["milliseconds", "millisecond", "millisec", "millisecs", "ms"]
+_SECOND_UNITS = ["seconds", "second", "sec", "secs", "s"]
+_MINUTE_UNITS = ["minutes", "minute", "min", "mins"]
+_HOUR_UNITS = ["hours", "hour", "hr", "hrs", "h"]
+_DAY_UNITS = ["day", "days", "d"]
+_MONTH_UNITS = ["month", "months"]
+_DTYPES = [np.dtype("int64"), np.dtype("float64")]
+_STANDARD_CALENDARS = [
+    "standard",
+    "gregorian",
+    "proleptic_gregorian"
+]
+_REAL_WORLD_CALENDARS = [
+    "julian",
+    "standard",
+    "gregorian",
+    "proleptic_gregorian"
+]
+_ARTIFICIAL_CALENDARS = ["noleap", "all_leap", "360_day"]
+
+
+@pytest.fixture(params=_SHAPES)
+def shape(request):
+    return request.param
+
+
+@pytest.fixture(params=_DTYPES)
+def dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=list(_EXPECTED_DATE_TYPES.keys()))
+def calendar(request):
+    return request.param
+
+
+@pytest.mark.parametrize("unit", _MICROSECOND_UNITS)
+def test_num2date_exact_microsecond_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 0, 0, 0, 1),
+                         date_type(2000, 1, 1, 0, 0, 0, 2),
+                         date_type(2000, 1, 1, 0, 0, 0, 3),
+                         date_type(2000, 1, 1, 0, 0, 0, 4)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _MILLISECOND_UNITS)
+def test_num2date_exact_millisecond_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 0, 0, 0, 1000),
+                         date_type(2000, 1, 1, 0, 0, 0, 2000),
+                         date_type(2000, 1, 1, 0, 0, 0, 3000),
+                         date_type(2000, 1, 1, 0, 0, 0, 4000)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _SECOND_UNITS)
+def test_num2date_exact_second_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 0, 0, 1, 0),
+                         date_type(2000, 1, 1, 0, 0, 2, 0),
+                         date_type(2000, 1, 1, 0, 0, 3, 0),
+                         date_type(2000, 1, 1, 0, 0, 4, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _MINUTE_UNITS)
+def test_num2date_exact_minute_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 0, 1, 0, 0),
+                         date_type(2000, 1, 1, 0, 2, 0, 0),
+                         date_type(2000, 1, 1, 0, 3, 0, 0),
+                         date_type(2000, 1, 1, 0, 4, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _HOUR_UNITS)
+def test_num2date_exact_hour_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 1, 0, 0, 0),
+                         date_type(2000, 1, 1, 2, 0, 0, 0),
+                         date_type(2000, 1, 1, 3, 0, 0, 0),
+                         date_type(2000, 1, 1, 4, 0, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _DAY_UNITS)
+def test_num2date_exact_day_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
+                         date_type(2000, 1, 3, 0, 0, 0, 0),
+                         date_type(2000, 1, 4, 0, 0, 0, 0),
+                         date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize("unit", _MONTH_UNITS)
+def test_num2date_exact_month_units(calendar, unit, shape, dtype):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 2, 1, 0, 0, 0, 0),
+                         date_type(2000, 3, 1, 0, 0, 0, 0),
+                         date_type(2000, 4, 1, 0, 0, 0, 0),
+                         date_type(2000, 5, 1, 0, 0, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"{unit} since 2000-01-01"
+
+    if calendar != "360_day":
+        with pytest.raises(ValueError):
+            num2date_exact(numeric_times, units=units, calendar=calendar)
+    else:
+        result = num2date_exact(numeric_times, units=units, calendar=calendar)
+        np.testing.assert_equal(result, expected)
+
+
+def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
+    date_type = datetime
+    expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
+                         date_type(2000, 1, 3, 0, 0, 0, 0),
+                         date_type(2000, 1, 4, 0, 0, 0, 0),
+                         date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"days since 2000-01-01"
+    if calendar not in _STANDARD_CALENDARS:
+        with pytest.raises(ValueError):
+            num2date_exact(numeric_times, units=units, calendar=calendar,
+                           only_use_python_datetimes=True,
+                           only_use_cftime_datetimes=False)
+    else:
+        result = num2date_exact(numeric_times, units=units, calendar=calendar,
+                                only_use_python_datetimes=True,
+                                only_use_cftime_datetimes=False)
+        np.testing.assert_equal(result, expected)
+
+
+def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
+    date_type = datetime
+    if calendar not in _STANDARD_CALENDARS:
+        date_type = _EXPECTED_DATE_TYPES[calendar]
+    else:
+        date_type = datetime
+
+    expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
+                         date_type(2000, 1, 3, 0, 0, 0, 0),
+                         date_type(2000, 1, 4, 0, 0, 0, 0),
+                         date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
+    numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
+    units = f"days since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar,
+                            only_use_python_datetimes=False,
+                            only_use_cftime_datetimes=False)
+    np.testing.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ["standard_calendar", "breakpoint"],
+    [("proleptic_gregorian", f"{MINYEAR - 1}-12-31T23:59:59.999999"),
+     ("gregorian", "1582-10-15"),
+     ("standard", "1582-10-15")]
+)
+def test_num2date_exact_only_use_python_datetimes_invalid_basedate(
+    standard_calendar,
+    breakpoint
+):
+    units = f"days since {breakpoint}"
+    numeric_times = np.array([1, 2, 3, 4])
+    with pytest.raises(ValueError, match="illegal calendar or reference date"):
+        num2date_exact(
+            numeric_times,
+            units=units,
+            calendar=standard_calendar,
+            only_use_python_datetimes=True,
+            only_use_cftime_datetimes=False
+        )
+
+
+@pytest.mark.parametrize("real_world_calendar", _REAL_WORLD_CALENDARS)
+def test_num2date_exact_invalid_zero_reference_year(real_world_calendar):
+    units = "days since 0000-01-01"
+    numeric_times = np.array([1, 2, 3, 4])
+    with pytest.raises(ValueError, match="zero not allowed as a reference"):
+        num2date_exact(
+            numeric_times,
+            units=units,
+            calendar=real_world_calendar
+        )
+
+
+@pytest.mark.parametrize("artificial_calendar", _ARTIFICIAL_CALENDARS)
+def test_num2date_exact_valid_zero_reference_year(artificial_calendar):
+    units = "days since 0000-01-01"
+    numeric_times = np.array([1, 2, 3, 4])
+    num2date_exact(numeric_times, units=units, calendar=artificial_calendar)
+
+
+def test_num2date_exact_uncastable_values(calendar):
+    units = "days since 2000-01-01"
+    numeric_times = np.array([1.0, np.pi])
+    with pytest.warns(UserWarning, match="Falling back to the inexact"):
+        num2date_exact(numeric_times, units=units, calendar=calendar)
+
+
+def test_num2date_exact_masked_array(calendar):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 1, 0, 0, 0),
+                         date_type(2000, 1, 1, 2, 0, 0, 0),
+                         date_type(2000, 1, 1, 3, 0, 0, 0),
+                         date_type(2000, 1, 1, 4, 0, 0, 0)])
+    mask = [False, False, True, False]
+    expected = np.ma.masked_array(expected, mask=mask)
+    numeric_times = np.ma.masked_array([1, 2, 3, 4], mask=mask)
+    units = f"hours since 2000-01-01"
+    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
 if __name__ == '__main__':
     unittest.main()

From 28d206c460e58b7a4c76940484360ebfdcd21739 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Mon, 25 May 2020 16:43:51 -0400
Subject: [PATCH 02/19] Remove unused cython imports

---
 cftime/_cftime.pyx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 3e97449e..1ff6dbcd 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -7,8 +7,6 @@ from cpython.object cimport (PyObject_RichCompare, Py_LT, Py_LE, Py_EQ,
 from numpy cimport int64_t, int32_t
 import cython
 import numpy as np
-cimport numpy as np
-cimport cpython.datetime
 import re
 import sys
 import time

From 03e8f92e2e3e7fe90aa4b7c691c10db85d9feb4c Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Mon, 25 May 2020 16:50:59 -0400
Subject: [PATCH 03/19] Provide nicer error message for invalid time units

---
 cftime/_cftime.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 1ff6dbcd..d3848a79 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -517,7 +517,7 @@ def num2date_exact(
         basedate = to_calendar_specific_datetime(basedate, calendar)
 
     if unit not in UNIT_CONVERSION_FACTORS:
-        raise ValueError("Invalid units provided.")
+        raise ValueError(f"Unsupported time units provided, '{unit}'.")
 
     if unit in ["months", "month"] and calendar != "360_day":
         raise ValueError("Units of months only valid for 360_day calendar.")

From 0692a9ff574e1a2417760a249d3182e538a66800 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Mon, 25 May 2020 16:52:42 -0400
Subject: [PATCH 04/19] Update comment regarding xarray.coding.times

---
 cftime/_cftime.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index d3848a79..d57a8f5a 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -457,7 +457,7 @@ def to_calendar_specific_datetime(datetime, calendar):
 
 
 def cast_to_int_if_safe(num):
-    """Copied from xarray.coding.times.py"""
+    """Adapted from xarray.coding.times.py"""
     if isinstance(num, np.ma.core.MaskedArray):
         int_num = np.ma.masked_array(num, dtype=np.int64)
     else:

From 90f9876b2ac432129763abe85ee891558fe1de91 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Mon, 25 May 2020 18:00:12 -0400
Subject: [PATCH 05/19] Use real_datetime instead of datetime; add docstring

---
 cftime/_cftime.pyx  | 48 +++++++++++++++++++++++++++++++++++++++++++--
 test/test_cftime.py |  5 ++---
 2 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index d57a8f5a..8f62786c 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -474,7 +474,51 @@ def num2date_exact(
     only_use_cftime_datetimes=True,
     only_use_python_datetimes=False
 ):
-    """Decode times exactly with timedelta arithmetic."""
+    """Decode times exactly with timedelta arithmetic.
+
+    Return datetime objects given numeric time values. The units
+    of the numeric time values are described by the `units` argument
+    and the `calendar` keyword. The returned datetime objects represent
+    UTC with no time-zone offset, even if the specified
+    `units` contain a time-zone offset.
+
+    **`times`**: numeric time values.
+
+    **`units`**: a string of the form `<time units> since <reference time>`
+    describing the time units. `<time units>` can be days, hours, minutes,
+    seconds, milliseconds or microseconds. `<reference time>` is the time
+    origin. `months_since` is allowed *only* for the `360_day` calendar.
+
+    **`calendar`**: describes the calendar used in the time calculations.
+    All the values currently defined in the
+    [CF metadata convention](http://cfconventions.org)
+    Valid calendars `'standard', 'gregorian', 'proleptic_gregorian'
+    'noleap', '365_day', '360_day', 'julian', 'all_leap', '366_day'`.
+    Default is `'standard'`, which is a mixed Julian/Gregorian calendar.
+
+    **`only_use_cftime_datetimes`**: if False, python datetime.datetime
+    objects are returned from num2date where possible; if True dates which
+    subclass cftime.datetime are returned for all calendars. Default `True`.
+
+    **`only_use_python_datetimes`**: always return python datetime.datetime
+    objects and raise an error if this is not possible. Ignored unless
+    `only_use_cftime_datetimes=False`. Default `False`.
+
+    returns a datetime instance, or an array of datetime instances with
+    microsecond accuracy, if possible.
+
+    ***Note***: If only_use_cftime_datetimes=False and
+    use_only_python_datetimes=False, the datetime instances
+    returned are 'real' python datetime
+    objects if `calendar='proleptic_gregorian'`, or
+    `calendar='standard'` or `'gregorian'`
+    and the date is after the breakpoint between the Julian and
+    Gregorian calendars (1582-10-15). Otherwise, they are ctime.datetime
+    objects which support some but not all the methods of native python
+    datetime objects. The datetime instances
+    do not contain a time-zone offset, even if the specified `units`
+    contains one.
+    """
     calendar = calendar.lower()
     basedate = _dateparse(units)
 
@@ -504,7 +548,7 @@ def num2date_exact(
         use_python_datetime = True
 
     if use_python_datetime:
-        basedate = datetime_python(
+        basedate = real_datetime(
             basedate.year,
             basedate.month,
             basedate.day,
diff --git a/test/test_cftime.py b/test/test_cftime.py
index 67b5d81b..4247f63b 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1690,7 +1690,7 @@ def test_num2date_exact_month_units(calendar, unit, shape, dtype):
 
 
 def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
-    date_type = datetime
+    date_type = real_datetime
     expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
                          date_type(2000, 1, 3, 0, 0, 0, 0),
                          date_type(2000, 1, 4, 0, 0, 0, 0),
@@ -1710,11 +1710,10 @@ def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
 
 
 def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
-    date_type = datetime
     if calendar not in _STANDARD_CALENDARS:
         date_type = _EXPECTED_DATE_TYPES[calendar]
     else:
-        date_type = datetime
+        date_type = real_datetime
 
     expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
                          date_type(2000, 1, 3, 0, 0, 0, 0),

From 54f89f7b3609308c86ce6d5b9af696c7cd423e12 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Wed, 27 May 2020 20:32:05 -0400
Subject: [PATCH 06/19] Remove f-strings for compatibility

---
 cftime/_cftime.pyx  |  2 +-
 test/test_cftime.py | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 8f62786c..77d80e51 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -561,7 +561,7 @@ def num2date_exact(
         basedate = to_calendar_specific_datetime(basedate, calendar)
 
     if unit not in UNIT_CONVERSION_FACTORS:
-        raise ValueError(f"Unsupported time units provided, '{unit}'.")
+        raise ValueError("Unsupported time units provided, {!r}.".format(unit))
 
     if unit in ["months", "month"] and calendar != "360_day":
         raise ValueError("Units of months only valid for 360_day calendar.")
diff --git a/test/test_cftime.py b/test/test_cftime.py
index 4247f63b..d8dada33 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1601,7 +1601,7 @@ def test_num2date_exact_microsecond_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 0, 3),
                          date_type(2000, 1, 1, 0, 0, 0, 4)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1614,7 +1614,7 @@ def test_num2date_exact_millisecond_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 0, 3000),
                          date_type(2000, 1, 1, 0, 0, 0, 4000)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1627,7 +1627,7 @@ def test_num2date_exact_second_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 3, 0),
                          date_type(2000, 1, 1, 0, 0, 4, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1640,7 +1640,7 @@ def test_num2date_exact_minute_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 3, 0, 0),
                          date_type(2000, 1, 1, 0, 4, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1653,7 +1653,7 @@ def test_num2date_exact_hour_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 3, 0, 0, 0),
                          date_type(2000, 1, 1, 4, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1666,7 +1666,7 @@ def test_num2date_exact_day_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 4, 0, 0, 0, 0),
                          date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
@@ -1679,7 +1679,7 @@ def test_num2date_exact_month_units(calendar, unit, shape, dtype):
                          date_type(2000, 4, 1, 0, 0, 0, 0),
                          date_type(2000, 5, 1, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"{unit} since 2000-01-01"
+    units = "{} since 2000-01-01".format(unit)
 
     if calendar != "360_day":
         with pytest.raises(ValueError):
@@ -1737,7 +1737,7 @@ def test_num2date_exact_only_use_python_datetimes_invalid_basedate(
     standard_calendar,
     breakpoint
 ):
-    units = f"days since {breakpoint}"
+    units = "days since {}".format(breakpoint)
     numeric_times = np.array([1, 2, 3, 4])
     with pytest.raises(ValueError, match="illegal calendar or reference date"):
         num2date_exact(

From 9020a6251be47b838560fc8ac6d635b76e03fcd9 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Wed, 27 May 2020 21:17:24 -0400
Subject: [PATCH 07/19] Missed a few f-strings...

---
 test/test_cftime.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/test_cftime.py b/test/test_cftime.py
index d8dada33..8028c968 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1696,7 +1696,7 @@ def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
                          date_type(2000, 1, 4, 0, 0, 0, 0),
                          date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"days since 2000-01-01"
+    units = "days since 2000-01-01"
     if calendar not in _STANDARD_CALENDARS:
         with pytest.raises(ValueError):
             num2date_exact(numeric_times, units=units, calendar=calendar,
@@ -1720,7 +1720,7 @@ def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
                          date_type(2000, 1, 4, 0, 0, 0, 0),
                          date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
-    units = f"days since 2000-01-01"
+    units = "days since 2000-01-01"
     result = num2date_exact(numeric_times, units=units, calendar=calendar,
                             only_use_python_datetimes=False,
                             only_use_cftime_datetimes=False)
@@ -1729,7 +1729,7 @@ def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
 
 @pytest.mark.parametrize(
     ["standard_calendar", "breakpoint"],
-    [("proleptic_gregorian", f"{MINYEAR - 1}-12-31T23:59:59.999999"),
+    [("proleptic_gregorian", "{}-12-31T23:59:59.999999".format(MINYEAR - 1),
      ("gregorian", "1582-10-15"),
      ("standard", "1582-10-15")]
 )
@@ -1784,7 +1784,7 @@ def test_num2date_exact_masked_array(calendar):
     mask = [False, False, True, False]
     expected = np.ma.masked_array(expected, mask=mask)
     numeric_times = np.ma.masked_array([1, 2, 3, 4], mask=mask)
-    units = f"hours since 2000-01-01"
+    units = "hours since 2000-01-01"
     result = num2date_exact(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 

From df84b36751fec2935c705c4fa6c859f8be1872ec Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Thu, 28 May 2020 05:47:24 -0400
Subject: [PATCH 08/19] Fix syntax error

---
 test/test_cftime.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_cftime.py b/test/test_cftime.py
index 8028c968..701eb779 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1729,7 +1729,7 @@ def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
 
 @pytest.mark.parametrize(
     ["standard_calendar", "breakpoint"],
-    [("proleptic_gregorian", "{}-12-31T23:59:59.999999".format(MINYEAR - 1),
+    [("proleptic_gregorian", "{}-12-31T23:59:59.999999".format(MINYEAR - 1)),
      ("gregorian", "1582-10-15"),
      ("standard", "1582-10-15")]
 )

From 25f77eeb0e521e93ad7b9f539536a0c38db40fda Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Fri, 29 May 2020 19:01:32 -0400
Subject: [PATCH 09/19] Remove unused shape variable

---
 cftime/_cftime.pyx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 77d80e51..a8b35f81 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -577,7 +577,6 @@ def num2date_exact(
             "inexact version of the num2date function.")
         return num2date(times, units, calendar, only_use_cftime_datetimes, only_use_python_datetimes)
 
-    shape = scaled_times.shape
     deltas = scaled_times.astype("timedelta64[us]").astype(timedelta)
     return basedate + deltas
 

From d20df96c17174e39f890dc690be096de3b2c39fc Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Fri, 29 May 2020 19:15:35 -0400
Subject: [PATCH 10/19] Rename num2date_exact to num2date_int

---
 cftime/__init__.py  |  2 +-
 cftime/_cftime.pyx  | 59 +++++++++++++++++++++++++++++++++++++++++-
 test/test_cftime.py | 62 ++++++++++++++++++++++-----------------------
 3 files changed, 90 insertions(+), 33 deletions(-)

diff --git a/cftime/__init__.py b/cftime/__init__.py
index 82a4a228..3c1ac34f 100644
--- a/cftime/__init__.py
+++ b/cftime/__init__.py
@@ -5,5 +5,5 @@
                          DatetimeGregorian, DatetimeProlepticGregorian
 from ._cftime import microsec_units, millisec_units, \
                          sec_units, hr_units, day_units, min_units
-from ._cftime import num2date, date2num, date2index, num2pydate, num2date_exact
+from ._cftime import num2date, date2num, date2index, num2pydate, num2date_float, num2date_int
 from ._cftime import __version__
diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index a8b35f81..711de76f 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -263,6 +263,7 @@ def num2pydate(times,units,calendar='standard'):
     """
     return num2date(times,units,calendar,only_use_cftime_datetimes=False,only_use_python_datetimes=True)
 
+
 def num2date(times,units,calendar='standard',\
              only_use_cftime_datetimes=True,only_use_python_datetimes=False):
     """num2date(times,units,calendar='standard',only_use_cftime_datetimes=True,only_use_python_datetimes=False)
@@ -298,6 +299,62 @@ def num2date(times,units,calendar='standard',\
     returns a datetime instance, or an array of datetime instances with
     approximately 100 microsecond accuracy.
 
+    ***Note***: If only_use_cftime_datetimes=False and
+    use_only_python_datetimes=False, the datetime instances
+    returned are 'real' python datetime
+    objects if `calendar='proleptic_gregorian'`, or
+    `calendar='standard'` or `'gregorian'`
+    and the date is after the breakpoint between the Julian and
+    Gregorian calendars (1582-10-15). Otherwise, they are ctime.datetime
+    objects which support some but not all the methods of native python
+    datetime objects. The datetime instances
+    do not contain a time-zone offset, even if the specified `units`
+    contains one.
+    """
+    return num2date_float(
+        times,
+        units,
+        calendar=calendar,
+        only_use_cftime_datetimes=only_use_cftime_datetimes,
+        only_use_python_datetimes=only_use_python_datetimes
+    )
+
+
+def num2date_float(times,units,calendar='standard',\
+             only_use_cftime_datetimes=True,only_use_python_datetimes=False):
+    """num2date(times,units,calendar='standard',only_use_cftime_datetimes=True,only_use_python_datetimes=False)
+
+    Return datetime objects given numeric time values. The units
+    of the numeric time values are described by the `units` argument
+    and the `calendar` keyword. The returned datetime objects represent
+    UTC with no time-zone offset, even if the specified
+    `units` contain a time-zone offset.
+
+    **`times`**: numeric time values.
+
+    **`units`**: a string of the form `<time units> since <reference time>`
+    describing the time units. `<time units>` can be days, hours, minutes,
+    seconds, milliseconds or microseconds. `<reference time>` is the time
+    origin. `months_since` is allowed *only* for the `360_day` calendar.
+
+    **`calendar`**: describes the calendar used in the time calculations.
+    All the values currently defined in the
+    [CF metadata convention](http://cfconventions.org)
+    Valid calendars `'standard', 'gregorian', 'proleptic_gregorian'
+    'noleap', '365_day', '360_day', 'julian', 'all_leap', '366_day'`.
+    Default is `'standard'`, which is a mixed Julian/Gregorian calendar.
+
+    **`only_use_cftime_datetimes`**: if False, python datetime.datetime
+    objects are returned from num2date where possible; if True dates which
+    subclass cftime.datetime are returned for all calendars. Default `True`.
+
+    **`only_use_python_datetimes`**: always return python datetime.datetime
+    objects and raise an error if this is not possible. Ignored unless
+    `only_use_cftime_datetimes=False`. Default `False`.
+
+    returns a datetime instance, or an array of datetime instances with
+    approximately 100 microsecond accuracy.
+
     ***Note***: If only_use_cftime_datetimes=False and
     use_only_python_datetimes=False, the datetime instances
     returned are 'real' python datetime
@@ -467,7 +524,7 @@ def cast_to_int_if_safe(num):
     return num
 
 
-def num2date_exact(
+def num2date_int(
     times,
     units,
     calendar='standard',
diff --git a/test/test_cftime.py b/test/test_cftime.py
index 701eb779..19ba37ea 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -17,7 +17,7 @@
 from cftime import (DateFromJulianDay, Datetime360Day, DatetimeAllLeap,
                     DatetimeGregorian, DatetimeJulian, DatetimeNoLeap,
                     DatetimeProlepticGregorian, JulianDayFromDate, _parse_date,
-                    date2index, date2num, num2date, utime, num2date_exact)
+                    date2index, date2num, num2date, utime, num2date_int)
 
 try:
     from datetime import timezone
@@ -1594,7 +1594,7 @@ def calendar(request):
 
 
 @pytest.mark.parametrize("unit", _MICROSECOND_UNITS)
-def test_num2date_exact_microsecond_units(calendar, unit, shape, dtype):
+def test_num2date_int_microsecond_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 0, 0, 0, 1),
                          date_type(2000, 1, 1, 0, 0, 0, 2),
@@ -1602,12 +1602,12 @@ def test_num2date_exact_microsecond_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 0, 4)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _MILLISECOND_UNITS)
-def test_num2date_exact_millisecond_units(calendar, unit, shape, dtype):
+def test_num2date_int_millisecond_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 0, 0, 0, 1000),
                          date_type(2000, 1, 1, 0, 0, 0, 2000),
@@ -1615,12 +1615,12 @@ def test_num2date_exact_millisecond_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 0, 4000)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _SECOND_UNITS)
-def test_num2date_exact_second_units(calendar, unit, shape, dtype):
+def test_num2date_int_second_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 0, 0, 1, 0),
                          date_type(2000, 1, 1, 0, 0, 2, 0),
@@ -1628,12 +1628,12 @@ def test_num2date_exact_second_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 0, 4, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _MINUTE_UNITS)
-def test_num2date_exact_minute_units(calendar, unit, shape, dtype):
+def test_num2date_int_minute_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 0, 1, 0, 0),
                          date_type(2000, 1, 1, 0, 2, 0, 0),
@@ -1641,12 +1641,12 @@ def test_num2date_exact_minute_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 0, 4, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _HOUR_UNITS)
-def test_num2date_exact_hour_units(calendar, unit, shape, dtype):
+def test_num2date_int_hour_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 1, 0, 0, 0),
                          date_type(2000, 1, 1, 2, 0, 0, 0),
@@ -1654,12 +1654,12 @@ def test_num2date_exact_hour_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 1, 4, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _DAY_UNITS)
-def test_num2date_exact_day_units(calendar, unit, shape, dtype):
+def test_num2date_int_day_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
                          date_type(2000, 1, 3, 0, 0, 0, 0),
@@ -1667,12 +1667,12 @@ def test_num2date_exact_day_units(calendar, unit, shape, dtype):
                          date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "{} since 2000-01-01".format(unit)
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 
 @pytest.mark.parametrize("unit", _MONTH_UNITS)
-def test_num2date_exact_month_units(calendar, unit, shape, dtype):
+def test_num2date_int_month_units(calendar, unit, shape, dtype):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 2, 1, 0, 0, 0, 0),
                          date_type(2000, 3, 1, 0, 0, 0, 0),
@@ -1683,13 +1683,13 @@ def test_num2date_exact_month_units(calendar, unit, shape, dtype):
 
     if calendar != "360_day":
         with pytest.raises(ValueError):
-            num2date_exact(numeric_times, units=units, calendar=calendar)
+            num2date_int(numeric_times, units=units, calendar=calendar)
     else:
-        result = num2date_exact(numeric_times, units=units, calendar=calendar)
+        result = num2date_int(numeric_times, units=units, calendar=calendar)
         np.testing.assert_equal(result, expected)
 
 
-def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
+def test_num2date_int_only_use_python_datetimes(calendar, shape, dtype):
     date_type = real_datetime
     expected = np.array([date_type(2000, 1, 2, 0, 0, 0, 0),
                          date_type(2000, 1, 3, 0, 0, 0, 0),
@@ -1699,17 +1699,17 @@ def test_num2date_exact_only_use_python_datetimes(calendar, shape, dtype):
     units = "days since 2000-01-01"
     if calendar not in _STANDARD_CALENDARS:
         with pytest.raises(ValueError):
-            num2date_exact(numeric_times, units=units, calendar=calendar,
+            num2date_int(numeric_times, units=units, calendar=calendar,
                            only_use_python_datetimes=True,
                            only_use_cftime_datetimes=False)
     else:
-        result = num2date_exact(numeric_times, units=units, calendar=calendar,
+        result = num2date_int(numeric_times, units=units, calendar=calendar,
                                 only_use_python_datetimes=True,
                                 only_use_cftime_datetimes=False)
         np.testing.assert_equal(result, expected)
 
 
-def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
+def test_num2date_int_use_pydatetime_if_possible(calendar, shape, dtype):
     if calendar not in _STANDARD_CALENDARS:
         date_type = _EXPECTED_DATE_TYPES[calendar]
     else:
@@ -1721,7 +1721,7 @@ def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
                          date_type(2000, 1, 5, 0, 0, 0, 0)]).reshape(shape)
     numeric_times = np.array([1, 2, 3, 4]).reshape(shape).astype(dtype)
     units = "days since 2000-01-01"
-    result = num2date_exact(numeric_times, units=units, calendar=calendar,
+    result = num2date_int(numeric_times, units=units, calendar=calendar,
                             only_use_python_datetimes=False,
                             only_use_cftime_datetimes=False)
     np.testing.assert_equal(result, expected)
@@ -1733,14 +1733,14 @@ def test_num2date_exact_use_pydatetime_if_possible(calendar, shape, dtype):
      ("gregorian", "1582-10-15"),
      ("standard", "1582-10-15")]
 )
-def test_num2date_exact_only_use_python_datetimes_invalid_basedate(
+def test_num2date_int_only_use_python_datetimes_invalid_basedate(
     standard_calendar,
     breakpoint
 ):
     units = "days since {}".format(breakpoint)
     numeric_times = np.array([1, 2, 3, 4])
     with pytest.raises(ValueError, match="illegal calendar or reference date"):
-        num2date_exact(
+        num2date_int(
             numeric_times,
             units=units,
             calendar=standard_calendar,
@@ -1750,11 +1750,11 @@ def test_num2date_exact_only_use_python_datetimes_invalid_basedate(
 
 
 @pytest.mark.parametrize("real_world_calendar", _REAL_WORLD_CALENDARS)
-def test_num2date_exact_invalid_zero_reference_year(real_world_calendar):
+def test_num2date_int_invalid_zero_reference_year(real_world_calendar):
     units = "days since 0000-01-01"
     numeric_times = np.array([1, 2, 3, 4])
     with pytest.raises(ValueError, match="zero not allowed as a reference"):
-        num2date_exact(
+        num2date_int(
             numeric_times,
             units=units,
             calendar=real_world_calendar
@@ -1762,20 +1762,20 @@ def test_num2date_exact_invalid_zero_reference_year(real_world_calendar):
 
 
 @pytest.mark.parametrize("artificial_calendar", _ARTIFICIAL_CALENDARS)
-def test_num2date_exact_valid_zero_reference_year(artificial_calendar):
+def test_num2date_int_valid_zero_reference_year(artificial_calendar):
     units = "days since 0000-01-01"
     numeric_times = np.array([1, 2, 3, 4])
-    num2date_exact(numeric_times, units=units, calendar=artificial_calendar)
+    num2date_int(numeric_times, units=units, calendar=artificial_calendar)
 
 
-def test_num2date_exact_uncastable_values(calendar):
+def test_num2date_int_uncastable_values(calendar):
     units = "days since 2000-01-01"
     numeric_times = np.array([1.0, np.pi])
     with pytest.warns(UserWarning, match="Falling back to the inexact"):
-        num2date_exact(numeric_times, units=units, calendar=calendar)
+        num2date_int(numeric_times, units=units, calendar=calendar)
 
 
-def test_num2date_exact_masked_array(calendar):
+def test_num2date_int_masked_array(calendar):
     date_type = _EXPECTED_DATE_TYPES[calendar]
     expected = np.array([date_type(2000, 1, 1, 1, 0, 0, 0),
                          date_type(2000, 1, 1, 2, 0, 0, 0),
@@ -1785,7 +1785,7 @@ def test_num2date_exact_masked_array(calendar):
     expected = np.ma.masked_array(expected, mask=mask)
     numeric_times = np.ma.masked_array([1, 2, 3, 4], mask=mask)
     units = "hours since 2000-01-01"
-    result = num2date_exact(numeric_times, units=units, calendar=calendar)
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
     np.testing.assert_equal(result, expected)
 
 

From a8bd58c7ec7ca2ad77c4a7bad1c5179fc59d2de9 Mon Sep 17 00:00:00 2001
From: jswhit <whitaker.jeffrey@gmail.com>
Date: Sat, 30 May 2020 10:02:27 -0600
Subject: [PATCH 11/19] use UNIT_CONVERSION_FACTORS in date2num

---
 cftime/_cftime.pyx | 22 ++++++----------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 711de76f..d9e12224 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -201,6 +201,11 @@ def date2num(dates,units,calendar='standard'):
             if basedate.year == 0:
                 msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
                 raise ValueError(msg)
+        if unit not in UNIT_CONVERSION_FACTORS:
+            raise ValueError("Unsupported time units provided, {!r}.".format(unit))
+        if unit in ["months", "month"] and calendar != "360_day":
+            raise ValueError("Units of months only valid for 360_day calendar.")
+        factor = UNIT_CONVERSION_FACTORS[unit]
 
         if (calendar == 'proleptic_gregorian' and basedate.year >= MINYEAR) or \
            (calendar in ['gregorian','standard'] and basedate > gregorian):
@@ -228,22 +233,7 @@ def date2num(dates,units,calendar='standard'):
                     times.append(None)
                 else:
                     td = date - basedate
-                    # total time in microseconds.
-                    totaltime = td.microseconds + (td.seconds + td.days * 24 * 3600) * 1.e6
-                    if unit in microsec_units:
-                        times.append(totaltime)
-                    elif unit in millisec_units:
-                        times.append(totaltime/1.e3)
-                    elif unit in sec_units:
-                        times.append(totaltime/1.e6)
-                    elif unit in min_units:
-                        times.append(totaltime/1.e6/60)
-                    elif unit in hr_units:
-                        times.append(totaltime/1.e6/3600)
-                    elif unit in day_units:
-                        times.append(totaltime/1.e6/3600./24.)
-                    else:
-                        raise ValueError('unsupported time units')
+                    times.append( (td/timedelta(microseconds=1)) / factor )
             if isscalar:
                 return times[0]
             else:

From a80784f783c8234cefd2051d09952c6d3cc041b5 Mon Sep 17 00:00:00 2001
From: jswhit <whitaker.jeffrey@gmail.com>
Date: Sat, 30 May 2020 10:45:31 -0600
Subject: [PATCH 12/19] fix merge conflict

---
 cftime/_cftime.pyx | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index d9e12224..f9ce30ff 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -228,12 +228,18 @@ def date2num(dates,units,calendar='standard'):
             for date in dates.flat:
                 if getattr(date, 'tzinfo',None) is not None:
                     date = date.replace(tzinfo=None) - date.utcoffset()
-
                 if ismasked and not date:
                     times.append(None)
                 else:
                     td = date - basedate
                     times.append( (td/timedelta(microseconds=1)) / factor )
+            if ismasked: # convert to masked array if input was masked array
+                times = np.array(times)
+                times = np.ma.masked_where(times==None,times)
+                if isscalar:
+                    return times[0]
+                else:
+                    return np.reshape(times, shape)
             if isscalar:
                 return times[0]
             else:

From 1ac905f40e0855d42c1cac3729f2ccbd83b6bd1b Mon Sep 17 00:00:00 2001
From: jswhit <whitaker.jeffrey@gmail.com>
Date: Sat, 30 May 2020 13:51:59 -0600
Subject: [PATCH 13/19] use total_seconds instead of division (fixes failing
 python 2.7 tests)

---
 cftime/_cftime.pyx | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index f9ce30ff..dae3572e 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -195,7 +195,11 @@ def date2num(dates,units,calendar='standard'):
         """
         calendar = calendar.lower()
         basedate = _dateparse(units)
-        (unit, ignore) = _datesplit(units)
+        (unit, isostring) = _datesplit(units)
+        # parse the date string to get utc_offset.
+        year, month, day, hour, minute, second, microsecond, utc_offset =\
+         _parse_date(isostring.strip())
+        #basedate =  basedate + utc_offset*timedelta(minutes=1)
         # real-world calendars limited to positive reference years.
         if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
             if basedate.year == 0:
@@ -232,7 +236,9 @@ def date2num(dates,units,calendar='standard'):
                     times.append(None)
                 else:
                     td = date - basedate
-                    times.append( (td/timedelta(microseconds=1)) / factor )
+                    # timedelta division only works python >= 3.2
+                    #times.append( (td/timedelta(microseconds=1)) / factor )
+                    times.append( (td.total_seconds()*1.e6) / factor )
             if ismasked: # convert to masked array if input was masked array
                 times = np.array(times)
                 times = np.ma.masked_where(times==None,times)

From f1e59105b77f90fb719bb1f7ddab5f11e6105d5c Mon Sep 17 00:00:00 2001
From: jswhit <whitaker.jeffrey@gmail.com>
Date: Sat, 30 May 2020 14:31:07 -0600
Subject: [PATCH 14/19] remove unused code

---
 cftime/_cftime.pyx | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index eaa0ad0c..021965bd 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -196,10 +196,6 @@ def date2num(dates,units,calendar='standard'):
         calendar = calendar.lower()
         basedate = _dateparse(units)
         (unit, isostring) = _datesplit(units)
-        # parse the date string to get utc_offset.
-        year, month, day, hour, minute, second, microsecond, utc_offset =\
-         _parse_date(isostring.strip())
-        #basedate =  basedate + utc_offset*timedelta(minutes=1)
         # real-world calendars limited to positive reference years.
         if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
             if basedate.year == 0:

From a8814fda94fc411c9abdbe8e401f8aabfbf38e85 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Tue, 2 Jun 2020 20:46:27 -0400
Subject: [PATCH 15/19] Add comment clarifying use of np.timedelta64

---
 cftime/_cftime.pyx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 711de76f..842c29e4 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -634,6 +634,8 @@ def num2date_int(
             "inexact version of the num2date function.")
         return num2date(times, units, calendar, only_use_cftime_datetimes, only_use_python_datetimes)
 
+    # Through np.timedelta64, convert integers scaled to have units of
+    # microseconds to datetime.timedelta objects.
     deltas = scaled_times.astype("timedelta64[us]").astype(timedelta)
     return basedate + deltas
 

From 7c245e4f8457a382cad814b6b76400f089daa1e5 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Tue, 2 Jun 2020 20:48:13 -0400
Subject: [PATCH 16/19] Add more detail to comment

---
 cftime/_cftime.pyx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 842c29e4..49dc7583 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -635,7 +635,8 @@ def num2date_int(
         return num2date(times, units, calendar, only_use_cftime_datetimes, only_use_python_datetimes)
 
     # Through np.timedelta64, convert integers scaled to have units of
-    # microseconds to datetime.timedelta objects.
+    # microseconds to datetime.timedelta objects, the timedelta type compatible
+    # with all cftime.datetime objects.
     deltas = scaled_times.astype("timedelta64[us]").astype(timedelta)
     return basedate + deltas
 

From 19b82378983b0d4665b29fefae27e48c4cacb58c Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Sat, 20 Jun 2020 14:15:06 -0400
Subject: [PATCH 17/19] Address review comments

---
 cftime/_cftime.pyx  | 92 ++++++++++++++++++++++++++++++++-------------
 test/test_cftime.py | 32 ++++++++++++++++
 2 files changed, 97 insertions(+), 27 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 49dc7583..9018df7c 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -311,7 +311,7 @@ def num2date(times,units,calendar='standard',\
     do not contain a time-zone offset, even if the specified `units`
     contains one.
     """
-    return num2date_float(
+    return num2date_int(
         times,
         units,
         calendar=calendar,
@@ -501,8 +501,13 @@ DATE_TYPES = {
 }
 
 
-def to_calendar_specific_datetime(datetime, calendar):
-    return DATE_TYPES[calendar](
+def to_calendar_specific_datetime(datetime, calendar, use_python_datetime):
+    if use_python_datetime:
+        date_type = real_datetime
+    else:
+        date_type = DATE_TYPES[calendar]
+
+    return date_type(
         datetime.year,
         datetime.month,
         datetime.day,
@@ -513,15 +518,52 @@ def to_calendar_specific_datetime(datetime, calendar):
     )
 
 
+_LONGDOUBLE_INTEGER_RANGE = np.longdouble(2 ** np.finfo(np.longdouble).nmant)
+_MAX_INT64 = np.iinfo("int64").max
+_MIN_INT64 = np.iinfo("int64").min
+
+
 def cast_to_int_if_safe(num):
     """Adapted from xarray.coding.times.py"""
-    if isinstance(num, np.ma.core.MaskedArray):
-        int_num = np.ma.masked_array(num, dtype=np.int64)
+    if np.issubdtype(num.dtype, np.integer):
+        return num
+    elif np.max(np.abs(num)) > _LONGDOUBLE_INTEGER_RANGE:
+        return num
+    else:
+        if isinstance(num, np.ma.core.MaskedArray):
+            int_num = np.ma.masked_array(num, dtype=np.int64)
+        else:
+            int_num = np.array(num, dtype=np.int64)
+        if (num == int_num).all():
+            num = int_num
+        return num
+
+
+def upcast_times(num):
+    """Cast times array to larger float or integer dtype before scaling
+    to units of microseconds.
+    """
+    if np.issubdtype(num.dtype, np.float):
+        return num.astype(np.longdouble)
     else:
-        int_num = np.array(num, dtype=np.int64)
-    if (num == int_num).all():
-        num = int_num
-    return num
+        return num.astype(np.int64)
+
+
+def safely_scale_times(num, factor):
+    """Scale times by a factor, casting to a longdouble if integer overflow
+    would occur."""
+    if np.issubdtype(num.dtype, np.float):
+        return factor * num
+    else:
+        # Python integers have arbitrary precision, so convert min and max
+        # returned by NumPy functions through item, prior to multiplying by
+        # factor.
+        minimum = np.min(num).item() * factor
+        maximum = np.max(num).item() * factor
+        if minimum < _MIN_INT64 or maximum > _MAX_INT64:
+            return num.astype(np.longdouble) * factor
+        else:
+            return num * factor
 
 
 def num2date_int(
@@ -604,18 +646,7 @@ def num2date_int(
         # return python datetime if possible.
         use_python_datetime = True
 
-    if use_python_datetime:
-        basedate = real_datetime(
-            basedate.year,
-            basedate.month,
-            basedate.day,
-            basedate.hour,
-            basedate.minute,
-            basedate.second,
-            basedate.microsecond
-        )
-    else:
-        basedate = to_calendar_specific_datetime(basedate, calendar)
+    basedate = to_calendar_specific_datetime(basedate, calendar, use_python_datetime)
 
     if unit not in UNIT_CONVERSION_FACTORS:
         raise ValueError("Unsupported time units provided, {!r}.".format(unit))
@@ -624,15 +655,22 @@ def num2date_int(
         raise ValueError("Units of months only valid for 360_day calendar.")
 
     factor = UNIT_CONVERSION_FACTORS[unit]
-    scaled_times = factor * times
-
+    times = np.asanyarray(times)  # Allow list as input
+    times = upcast_times(times)
+    scaled_times = safely_scale_times(times, factor)
     scaled_times = cast_to_int_if_safe(scaled_times)
     if not np.issubdtype(scaled_times.dtype, np.integer):
         warnings.warn(
-            "times must have integer dtype or be able to be safely cast to an "
-            "integer dtype to be decoded exactly.  Falling back to the "
-            "inexact version of the num2date function.")
-        return num2date(times, units, calendar, only_use_cftime_datetimes, only_use_python_datetimes)
+            "times must be able to be safely converted to an integer number "
+            "of microseconds to be decoded exactly.  Falling back to the "
+            "older inexact version of the num2date function.")
+        return num2date_float(
+            times,
+            units,
+            calendar,
+            only_use_cftime_datetimes,
+            only_use_python_datetimes
+        )
 
     # Through np.timedelta64, convert integers scaled to have units of
     # microseconds to datetime.timedelta objects, the timedelta type compatible
diff --git a/test/test_cftime.py b/test/test_cftime.py
index 19ba37ea..c1463197 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1789,5 +1789,37 @@ def test_num2date_int_masked_array(calendar):
     np.testing.assert_equal(result, expected)
 
 
+def test_num2date_int_out_of_range():
+    numeric_times = 12 * np.array([200000, 400000, 600000])
+    units = "months since 2000-01-01"
+    with pytest.warns(UserWarning, match="Falling back to the inexact"):
+        num2date_int(numeric_times, units=units, calendar="360_day")
+
+
+def test_num2date_int_list_input(calendar):
+    date_type = _EXPECTED_DATE_TYPES[calendar]
+    expected = np.array([date_type(2000, 1, 1, 1, 0, 0, 0),
+                         date_type(2000, 1, 1, 2, 0, 0, 0),
+                         date_type(2000, 1, 1, 3, 0, 0, 0),
+                         date_type(2000, 1, 1, 4, 0, 0, 0)])
+    numeric_times = [1, 2, 3, 4]
+    units = "hours since 2000-01-01"
+    result = num2date_int(numeric_times, units=units, calendar=calendar)
+    np.testing.assert_equal(result, expected)
+
+
+def test_num2date_int_integer_upcast_required():
+    numeric_times = np.array([30, 60, 90, 120], dtype=np.int32)
+    units = "minutes since 2000-01-01"
+    expected = np.array([
+        Datetime360Day(2000, 1, 1, 0, 30, 0),
+        Datetime360Day(2000, 1, 1, 1, 0, 0),
+        Datetime360Day(2000, 1, 1, 1, 30, 0),
+        Datetime360Day(2000, 1, 1, 2, 0, 0)
+    ])
+    result = num2date_int(numeric_times, units=units, calendar="360_day")
+    np.testing.assert_equal(result, expected)
+
+
 if __name__ == '__main__':
     unittest.main()

From aa83419f65f2e933e6bad623b79ab430ff823190 Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Sat, 20 Jun 2020 14:33:22 -0400
Subject: [PATCH 18/19] Raise ValueError if OverflowError occurs

---
 cftime/_cftime.pyx  | 13 ++++++++-----
 test/test_cftime.py |  4 ++--
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index 877db12b..caa98dbe 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -532,7 +532,7 @@ _MIN_INT64 = np.iinfo("int64").min
 
 def cast_to_int_if_safe(num):
     """Adapted from xarray.coding.times.py"""
-    if np.issubdtype(num.dtype, np.integer):
+    if num.dtype.kind in "iu":
         return num
     elif np.max(np.abs(num)) > _LONGDOUBLE_INTEGER_RANGE:
         return num
@@ -550,7 +550,7 @@ def upcast_times(num):
     """Cast times array to larger float or integer dtype before scaling
     to units of microseconds.
     """
-    if np.issubdtype(num.dtype, np.float):
+    if num.dtype.kind == "f":
         return num.astype(np.longdouble)
     else:
         return num.astype(np.int64)
@@ -559,7 +559,7 @@ def upcast_times(num):
 def safely_scale_times(num, factor):
     """Scale times by a factor, casting to a longdouble if integer overflow
     would occur."""
-    if np.issubdtype(num.dtype, np.float):
+    if num.dtype.kind == "f":
         return factor * num
     else:
         # Python integers have arbitrary precision, so convert min and max
@@ -666,7 +666,7 @@ def num2date_int(
     times = upcast_times(times)
     scaled_times = safely_scale_times(times, factor)
     scaled_times = cast_to_int_if_safe(scaled_times)
-    if not np.issubdtype(scaled_times.dtype, np.integer):
+    if scaled_times.dtype.kind not in "iu":
         warnings.warn(
             "times must be able to be safely converted to an integer number "
             "of microseconds to be decoded exactly.  Falling back to the "
@@ -683,7 +683,10 @@ def num2date_int(
     # microseconds to datetime.timedelta objects, the timedelta type compatible
     # with all cftime.datetime objects.
     deltas = scaled_times.astype("timedelta64[us]").astype(timedelta)
-    return basedate + deltas
+    try:
+        return basedate + deltas
+    except OverflowError:
+        raise ValueError("OverflowError in python datetime, probably because year < datetime.MINYEAR")
 
 
 def date2index(dates, nctime, calendar=None, select='exact'):
diff --git a/test/test_cftime.py b/test/test_cftime.py
index f8c17533..585895d7 100644
--- a/test/test_cftime.py
+++ b/test/test_cftime.py
@@ -1799,7 +1799,7 @@ def test_num2date_int_valid_zero_reference_year(artificial_calendar):
 def test_num2date_int_uncastable_values(calendar):
     units = "days since 2000-01-01"
     numeric_times = np.array([1.0, np.pi])
-    with pytest.warns(UserWarning, match="Falling back to the inexact"):
+    with pytest.warns(UserWarning, match="Falling back to the older inexact"):
         num2date_int(numeric_times, units=units, calendar=calendar)
 
 
@@ -1820,7 +1820,7 @@ def test_num2date_int_masked_array(calendar):
 def test_num2date_int_out_of_range():
     numeric_times = 12 * np.array([200000, 400000, 600000])
     units = "months since 2000-01-01"
-    with pytest.warns(UserWarning, match="Falling back to the inexact"):
+    with pytest.warns(UserWarning, match="Falling back to the older inexact"):
         num2date_int(numeric_times, units=units, calendar="360_day")
 
 

From 89b4ca0df71efe269fe4dd198bbfe18fbc51ac6c Mon Sep 17 00:00:00 2001
From: Spencer Clark <spencerkclark@gmail.com>
Date: Sat, 20 Jun 2020 14:35:04 -0400
Subject: [PATCH 19/19] Make error message less Python datetime specific

---
 cftime/_cftime.pyx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cftime/_cftime.pyx b/cftime/_cftime.pyx
index caa98dbe..b3f32cff 100644
--- a/cftime/_cftime.pyx
+++ b/cftime/_cftime.pyx
@@ -686,7 +686,7 @@ def num2date_int(
     try:
         return basedate + deltas
     except OverflowError:
-        raise ValueError("OverflowError in python datetime, probably because year < datetime.MINYEAR")
+        raise ValueError("OverflowError in datetime, possibly because year < datetime.MINYEAR")
 
 
 def date2index(dates, nctime, calendar=None, select='exact'):