Merge pull request #376 from shoyer/fallback-time-units

BUG: Fix failing to determine time units

Author: shoyer

doc/whats-new.rst

@@ -72,7 +72,6 @@ Enhancements
 - :py:func:`~xray.open_dataset` and :py:meth:`~xray.Dataset.to_netcdf` now
   accept an ``engine`` argument to explicitly select which underlying library
   (netcdf4 or scipy) is used for reading/writing a netCDF file.
-- New documentation section on :ref:`combining multiple files`.
 
 .. _same as pandas: http://pandas.pydata.org/pandas-docs/stable/timeseries.html#up-and-downsampling
 
@@ -81,13 +80,15 @@ Bug fixes
 
 - Fixed a bug where data netCDF variables read from disk with
   ``engine='scipy'`` could still be associated with the file on disk, even
-  after closing the file (`issue`:341:). This manifested itself in warnings
+  after closing the file (:issue:`341`). This manifested itself in warnings
   about mmapped arrays and segmentation faults (if the data was accessed).
 - Silenced spurious warnings about all-NaN slices when using nan-aware
-  aggregation methods (`issue`:344:).
+  aggregation methods (:issue:`344`).
 - Dataset aggregations with ``keep_attrs=True`` now preserve attributes on
   data variables, not just the dataset itself.
 - Tests for xray now pass when run on Windows. DOUBLE CHECK THIS.
+- Fixed a regression in v0.4 where saving to netCDF could fail with the error
+  ``ValueError: could not automatically determine time units``.
 
 v0.4 (2 March, 2015)
 --------------------

xray/conventions.py

@@ -157,7 +157,7 @@ def _infer_time_units_from_diff(unique_timedeltas):
         diffs = unique_timedeltas / unit_delta
         if np.all(diffs == diffs.astype(int)):
             return time_unit
-    raise ValueError('could not automatically determine time units')
+    return 'seconds'
 
 
 def infer_datetime_units(dates):
@@ -226,9 +226,7 @@ def encode_cf_datetime(dates, units=None, calendar=None):
     """Given an array of datetime objects, returns the tuple `(num, units,
     calendar)` suitable for a CF complient time variable.
 
-    Unlike encode_cf_datetime, this function does not (yet) speedup encoding
-    of datetime64 arrays. However, unlike `date2num`, it can handle datetime64
-    arrays.
+    Unlike `date2num`, this function can handle datetime64 arrays.
 
     See also
     --------

xray/test/test_conventions.py

@@ -107,24 +107,25 @@ class TestDatetime(TestCase):
     def test_cf_datetime(self):
         import netCDF4 as nc4
         for num_dates, units in [
-                (np.arange(100), 'days since 2000-01-01'),
-                (np.arange(100).reshape(10, 10), 'days since 2000-01-01'),
-                (12300 + np.arange(50), 'hours since 1680-01-01 00:00:00'),
+                (np.arange(10), 'days since 2000-01-01'),
+                (np.arange(10).reshape(2, 5), 'days since 2000-01-01'),
+                (12300 + np.arange(5), 'hours since 1680-01-01 00:00:00'),
                 # here we add a couple minor formatting errors to test
                 # the robustness of the parsing algorithm.
-                (12300 + np.arange(50), 'hour since 1680-01-01  00:00:00'),
-                (12300 + np.arange(50), u'Hour  since 1680-01-01 00:00:00'),
-                (12300 + np.arange(50), ' Hour  since  1680-01-01 00:00:00 '),
+                (12300 + np.arange(5), 'hour since 1680-01-01  00:00:00'),
+                (12300 + np.arange(5), u'Hour  since 1680-01-01 00:00:00'),
+                (12300 + np.arange(5), ' Hour  since  1680-01-01 00:00:00 '),
                 (10, 'days since 2000-01-01'),
                 ([10], 'daYs  since 2000-01-01'),
                 ([[10]], 'days since 2000-01-01'),
                 ([10, 10], 'days since 2000-01-01'),
                 (0, 'days since 1000-01-01'),
                 ([0], 'days since 1000-01-01'),
                 ([[0]], 'days since 1000-01-01'),
-                (np.arange(20), 'days since 1000-01-01'),
-                (np.arange(0, 100000, 10000), 'days since 1900-01-01'),
+                (np.arange(2), 'days since 1000-01-01'),
+                (np.arange(0, 100000, 20000), 'days since 1900-01-01'),
                 (17093352.0, 'hours since 1-1-1 00:00:0.0'),
+                ([0.5, 1.5], 'hours since 1900-01-01T00:00:00'),
                 ]:
             for calendar in ['standard', 'gregorian', 'proleptic_gregorian']:
                 expected = _ensure_naive_tz(nc4.num2date(num_dates, units, calendar))
@@ -152,15 +153,15 @@ def test_cf_datetime(self):
                     # units/encoding cannot be preserved in this case:
                     # (Pdb) pd.to_datetime('1-1-1 00:00:0.0')
                     # Timestamp('2001-01-01 00:00:00')
-                    self.assertArrayEqual(num_dates, np.around(encoded))
+                    self.assertArrayEqual(num_dates, np.around(encoded, 1))
                     if (hasattr(num_dates, 'ndim') and num_dates.ndim == 1
                             and '1000' not in units):
                         # verify that wrapping with a pandas.Index works
                         # note that it *does not* currently work to even put
                         # non-datetime64 compatible dates into a pandas.Index :(
                         encoded, _, _ = conventions.encode_cf_datetime(
                             pd.Index(actual), units, calendar)
-                        self.assertArrayEqual(num_dates, np.around(encoded))
+                        self.assertArrayEqual(num_dates, np.around(encoded, 1))
 
     def test_decoded_cf_datetime_array(self):
         actual = conventions.DecodedCFDatetimeArray(
@@ -344,7 +345,10 @@ def test_infer_datetime_units(self):
                                   '1900-01-02 00:00:01'],
                                  'seconds since 1900-01-01 00:00:00'),
                                 (pd.to_datetime(['1900-01-01', '1900-01-02', 'NaT']),
-                                 'days since 1900-01-01 00:00:00')]:
+                                 'days since 1900-01-01 00:00:00'),
+                                (pd.to_datetime(['1900-01-01',
+                                                 '1900-01-02T00:00:00.005']),
+                                 'seconds since 1900-01-01 00:00:00')]:
             self.assertEqual(expected, conventions.infer_datetime_units(dates))
 
     def test_infer_timedelta_units(self):