CFTimeIndex

xarray/__init__.py

@@ -14,7 +14,7 @@
 
 from .backends.api import (open_dataset, open_dataarray, open_mfdataset,
                            save_mfdataset)
-from .conventions import decode_cf
+from .conventions.coding import decode_cf
 
 try:
     from .version import version as __version__

xarray/backends/api.py

@@ -10,8 +10,9 @@
 
 import numpy as np
 
-from .. import backends, conventions
+from .. import backends
 from .common import ArrayWriter, GLOBAL_LOCK
+from ..conventions import coding
 from ..core import indexing
 from ..core.combine import auto_combine
 from ..core.utils import close_on_error, is_remote_uri
@@ -217,7 +218,7 @@ def open_dataset(filename_or_obj, group=None, decode_cf=True,
         cache = chunks is None
 
     def maybe_decode_store(store, lock=False):
-        ds = conventions.decode_cf(
+        ds = coding.decode_cf(
             store, mask_and_scale=mask_and_scale, decode_times=decode_times,
             concat_characters=concat_characters, decode_coords=decode_coords,
             drop_variables=drop_variables)

xarray/backends/common.py

@@ -8,7 +8,7 @@
 from collections import Mapping
 from distutils.version import StrictVersion
 
-from ..conventions import cf_encoder
+from ..conventions.coding import cf_encoder
 from ..core.utils import FrozenOrderedDict
 from ..core.pycompat import iteritems, dask_array_type
 

xarray/backends/netCDF4_.py

@@ -7,7 +7,7 @@
 import numpy as np
 
 from .. import Variable
-from ..conventions import pop_to
+from ..conventions.coding import pop_to
 from ..core import indexing
 from ..core.utils import (FrozenOrderedDict, NDArrayMixin,
                           close_on_error, is_remote_uri)

xarray/backends/netcdf3.py

@@ -5,7 +5,8 @@
 
 import numpy as np
 
-from .. import conventions, Variable
+from .. import Variable
+from ..conventions import coding
 from ..core import ops
 from ..core.pycompat import basestring, unicode_type, OrderedDict
 
@@ -56,7 +57,7 @@ def coerce_nc3_dtype(arr):
 
 def maybe_convert_to_char_array(data, dims):
     if data.dtype.kind == 'S' and data.dtype.itemsize > 1:
-        data = conventions.string_to_char(data)
+        data = coding.string_to_char(data)
         dims = dims + ('string%s' % data.shape[-1],)
     return data, dims
 

xarray/conventions.py → xarray/conventions/coding.py

@@ -11,10 +11,10 @@
 from collections import defaultdict
 from pandas.tslib import OutOfBoundsDatetime
 
-from .core import indexing, ops, utils
-from .core.formatting import format_timestamp, first_n_items, last_item
-from .core.variable import as_variable, Variable
-from .core.pycompat import iteritems, OrderedDict, PY3, basestring
+from ..core import indexing, ops, utils
+from ..core.formatting import format_timestamp, first_n_items, last_item
+from ..core.variable import as_variable, Variable
+from ..core.pycompat import iteritems, OrderedDict, PY3, basestring
 
 
 # standard calendars recognized by netcdftime
@@ -929,8 +929,8 @@ def decode_cf(obj, concat_characters=True, mask_and_scale=True,
     -------
     decoded : Dataset
     """
-    from .core.dataset import Dataset
-    from .backends.common import AbstractDataStore
+    from ..core.dataset import Dataset
+    from ..backends.common import AbstractDataStore
 
     if isinstance(obj, Dataset):
         vars = obj._variables

xarray/core/netcdftimeindex.py → xarray/conventions/netcdftimeindex.py

@@ -4,7 +4,8 @@
 import numpy as np
 import pandas as pd
 
-from pandas.lib import isscalar
+from xarray.core import pycompat
+from xarray.core.utils import is_scalar
 
 
 def named(name, pattern):
@@ -35,10 +36,12 @@ def build_pattern(date_sep='\-', datetime_sep='T', time_sep='\:'):
     return '^' + trailing_optional(pattern_list) + '$'
 
 
+basic_pattern = build_pattern(date_sep='', time_sep='')
+extended_pattern = build_pattern()
+patterns = [basic_pattern, extended_pattern]
+
+
 def parse_iso8601(datetime_string):
-    basic_pattern = build_pattern(date_sep='', time_sep='')
-    extended_pattern = build_pattern()
-    patterns = [basic_pattern, extended_pattern]
     for pattern in patterns:
         match = re.match(pattern, datetime_string)
         if match:
@@ -54,13 +57,22 @@ def _parse_iso8601_with_reso(date_type, timestr):
     for attr in ['year', 'month', 'day', 'hour', 'minute', 'second']:
         value = result.get(attr, None)
         if value is not None:
+            # Note ISO8601 conventions allow for fractional seconds; casting
+            # to an int means all seconds values get rounded down to the
+            # nearest integer.  TODO: Consider adding support for sub-second
+            # resolution?
             replace[attr] = int(value)
             resolution = attr
 
     return default.replace(**replace), resolution
 
 
 def _parsed_string_to_bounds(date_type, resolution, parsed):
+    """Generalization of
+    pandas.tseries.index.DatetimeIndex._parsed_string_to_bounds
+    for use with non-standard calendars and netcdftime._netcdftime.datetime
+    objects.
+    """
     if resolution == 'year':
         return (date_type(parsed.year, 1, 1),
                 date_type(parsed.year + 1, 1, 1) - timedelta(microseconds=1))
@@ -90,10 +102,12 @@ def _parsed_string_to_bounds(date_type, resolution, parsed):
 
 
 def get_date_field(datetimes, field):
+    """Adapted from pandas.tslib.get_date_field"""
     return [getattr(date, field) for date in datetimes]
 
 
 def _field_accessor(name, docstring=None):
+    """Adapted from pandas.tseries.index._field_accessor"""
     def f(self):
         return get_date_field(self._data, name)
 
@@ -106,9 +120,23 @@ def get_date_type(self):
     return type(self._data[0])
 
 
+def assert_all_same_netcdftime_datetimes(data):
+    from netcdftime._netcdftime import datetime
+
+    if not isinstance(data[0], datetime):
+        raise TypeError(
+            'NetCDFTimeIndex requires netcdftime._netcdftime.datetime'
+            ' objects.')
+    if not all(isinstance(value, type(data[0])) for value in data):
+        raise TypeError(
+            'NetCDFTimeIndex requires using netcdftime._netcdftime.datetime'
+            ' objects of all the same type.')
+
+
 class NetCDFTimeIndex(pd.Index):
     def __new__(cls, data):
         result = object.__new__(cls)
+        assert_all_same_netcdftime_datetimes(data)
         result._data = np.array(data)
         return result
 
@@ -122,37 +150,33 @@ def __new__(cls, data):
                                   'The microseconds of the datetime')
     date_type = property(get_date_type)
 
-    def _partial_date_slice(self, resolution, parsed,
-                            use_lhs=True, use_rhs=True):
+    def _partial_date_slice(self, resolution, parsed):
+        """Adapted from
+        pandas.tseries.index.DatetimeIndex._partial_date_slice"""
         start, end = _parsed_string_to_bounds(self.date_type, resolution,
                                               parsed)
-        lhs_mask = (self._data >= start) if use_lhs else True
-        rhs_mask = (self._data <= end) if use_rhs else True
+        lhs_mask = (self._data >= start)
+        rhs_mask = (self._data <= end)
         return (lhs_mask & rhs_mask).nonzero()[0]
 
-    def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
+    def _get_string_slice(self, key):
+        """Adapted from pandas.tseries.index.DatetimeIndex._get_string_slice"""
         parsed, resolution = _parse_iso8601_with_reso(self.date_type, key)
-        loc = self._partial_date_slice(resolution, parsed, use_lhs, use_rhs)
+        loc = self._partial_date_slice(resolution, parsed)
         return loc
 
     def get_loc(self, key, method=None, tolerance=None):
-        if isinstance(key, pd.compat.string_types):
-            result = self._get_string_slice(key)
-            # Prevents problem with __contains__ if key corresponds to only
-            # the first element in index (if we leave things as a list,
-            # np.any([0]) is False).
-            # Also coerces things to scalar coords in xarray if possible,
-            # which is consistent with the behavior with a DatetimeIndex.
-            if len(result) == 1:
-                return result[0]
-            else:
-                return result
+        """Adapted from pandas.tseries.index.DatetimeIndex.get_loc"""
+        if isinstance(key, pycompat.basestring):
+            return self._get_string_slice(key)
         else:
             return pd.Index.get_loc(self, key, method=method,
                                     tolerance=tolerance)
 
     def _maybe_cast_slice_bound(self, label, side, kind):
-        if isinstance(label, pd.compat.string_types):
+        """Adapted from
+        pandas.tseries.index.DatetimeIndex._maybe_cast_slice_bound"""
+        if isinstance(label, pycompat.basestring):
             parsed, resolution = _parse_iso8601_with_reso(self.date_type,
                                                           label)
             start, end = _parsed_string_to_bounds(self.date_type, resolution,
@@ -166,15 +190,19 @@ def _maybe_cast_slice_bound(self, label, side, kind):
     # TODO: Add ability to use integer range outside of iloc?
     # e.g. series[1:5].
     def get_value(self, series, key):
+        """Adapted from pandas.tseries.index.DatetimeIndex.get_value"""
         if not isinstance(key, slice):
             return series.iloc[self.get_loc(key)]
         else:
             return series.iloc[self.slice_indexer(
                 key.start, key.stop, key.step)]
 
     def __contains__(self, key):
+        """Adapted from
+        pandas.tseries.base.DatetimeIndexOpsMixin.__contains__"""
         try:
             result = self.get_loc(key)
-            return isscalar(result) or type(result) == slice or np.any(result)
+            return (is_scalar(result) or type(result) == slice or
+                    (isinstance(result, np.ndarray) and result.size))
         except (KeyError, TypeError, ValueError):
             return False

xarray/convert.py

@@ -7,7 +7,7 @@
 import numpy as np
 
 from .core.dataarray import DataArray
-from .conventions import (
+from .conventions.coding import (
     maybe_encode_timedelta, maybe_encode_datetime, decode_cf)
 
 ignored_attrs = set(['name', 'tileIndex'])

xarray/core/dataset.py

@@ -16,8 +16,8 @@
 from . import indexing
 from . import alignment
 from . import formatting
-from .. import conventions
 from .alignment import align
+from ..conventions import coding
 from .coordinates import DatasetCoordinates, LevelCoordinatesSource, Indexes
 from .common import ImplementsDatasetReduce, BaseDataObject
 from .merge import (dataset_update_method, dataset_merge_method,
@@ -875,7 +875,7 @@ def dump_to_store(self, store, encoder=None, sync=True, encoding=None,
         """Store dataset contents to a backends.*DataStore object."""
         if encoding is None:
             encoding = {}
-        variables, attrs = conventions.encode_dataset_coordinates(self)
+        variables, attrs = coding.encode_dataset_coordinates(self)
 
         check_encoding = set()
         for k, enc in encoding.items():