Rename Index (formerly Coordinate) to XIndex

Fixes pydata#178

Author: shoyer

test/test_data_array.py

@@ -3,7 +3,7 @@
 from copy import deepcopy
 from textwrap import dedent
 
-from xray import Dataset, DataArray, Index, Variable, align
+from xray import Dataset, DataArray, XIndex, Variable, align
 from xray.pycompat import iteritems, OrderedDict
 from . import TestCase, ReturnItem, source_ndarray
 
@@ -250,7 +250,7 @@ def test_loc(self):
         self.assertTrue(np.all(da.values == 0))
 
     def test_indexes(self):
-        indexes = [Index('x', [-1, -2]), Index('y', [0, 1, 2])]
+        indexes = [XIndex('x', [-1, -2]), XIndex('y', [0, 1, 2])]
         da = DataArray(np.random.randn(2, 3), indexes, name='foo')
 
         self.assertEquals(2, len(da.indexes))

test/test_dataset.py

@@ -136,7 +136,7 @@ def test_indexes_create(self):
         attributes = {'foo': 'bar'}
         a['x'] = ('x', vec, attributes)
         self.assertTrue('x' in a.indexes)
-        self.assertIsInstance(a.indexes['x'].as_pandas, pd.Index)
+        self.assertIsInstance(a.indexes['x'].as_index, pd.Index)
         self.assertVariableIdentical(a.indexes['x'], a.variables['x'])
         b = Dataset()
         b['x'] = ('x', vec, attributes)
@@ -467,7 +467,7 @@ def test_virtual_variables(self):
         self.assertVariableEqual(data['time.dayofyear'],
                                  Variable('time', 1 + np.arange(20)))
         self.assertArrayEqual(data['time.month'].values,
-                              data.variables['time'].as_pandas.month)
+                              data.variables['time'].as_index.month)
         self.assertArrayEqual(data['time.season'].values, 1)
         # test virtual variable math
         self.assertArrayEqual(data['time.dayofyear'] + 1, 2 + np.arange(20))
@@ -563,7 +563,7 @@ def test_groupby_errors(self):
         with self.assertRaisesRegexp(ValueError, 'length does not match'):
             data.groupby(data['dim1'][:3])
         with self.assertRaisesRegexp(ValueError, "must have a 'dimensions'"):
-            data.groupby(data.indexes['dim1'].as_pandas)
+            data.groupby(data.indexes['dim1'].as_index)
 
     def test_groupby_reduce(self):
         data = Dataset({'xy': (['x', 'y'], np.random.randn(3, 4)),

test/test_indexing.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from xray import indexing, variable, Dataset, Variable, Index
+from xray import indexing, variable, Dataset, Variable, XIndex
 from . import TestCase, ReturnItem
 
 
@@ -65,7 +65,7 @@ def test_orthogonal_indexer(self):
 
     def test_convert_label_indexer(self):
         # TODO: add tests that aren't just for edge cases
-        coord = Index('x', [1, 2, 3])
+        coord = XIndex('x', [1, 2, 3])
         with self.assertRaisesRegexp(ValueError, 'not all values found'):
             indexing.convert_label_indexer(coord, [0])
         with self.assertRaises(KeyError):

test/test_variable.py

@@ -7,7 +7,7 @@
 import pandas as pd
 
 from xray import Variable, Dataset, DataArray, indexing
-from xray.variable import (Index, as_variable, NumpyArrayAdapter,
+from xray.variable import (XIndex, as_variable, NumpyArrayAdapter,
                            PandasIndexAdapter, _as_compatible_data)
 from xray.pycompat import PY3, OrderedDict
 
@@ -171,9 +171,9 @@ def test_1d_math(self):
         self.assertEqual(float, (0 + v).values.dtype)
         # check types of returned data
         self.assertIsInstance(+v, Variable)
-        self.assertNotIsInstance(+v, Index)
+        self.assertNotIsInstance(+v, XIndex)
         self.assertIsInstance(0 + v, Variable)
-        self.assertNotIsInstance(0 + v, Index)
+        self.assertNotIsInstance(0 + v, XIndex)
 
     def test_1d_reduce(self):
         x = np.arange(5)
@@ -194,7 +194,7 @@ def test_array_interface(self):
         # test ufuncs
         self.assertVariableIdentical(np.sin(v), self.cls(['x'], np.sin(x)))
         self.assertIsInstance(np.sin(v), Variable)
-        self.assertNotIsInstance(np.sin(v), Index)
+        self.assertNotIsInstance(np.sin(v), XIndex)
 
     def example_1d_objects(self):
         for data in [range(3),
@@ -299,7 +299,7 @@ def test_numpy_same_methods(self):
         self.assertEqual(v.item(), 0)
         self.assertIs(type(v.item()), float)
 
-        v = Index('x', np.arange(5))
+        v = XIndex('x', np.arange(5))
         self.assertEqual(2, v.searchsorted(2))
 
     def test_datetime64_conversion(self):
@@ -566,27 +566,27 @@ def test_reduce_keep_attrs(self):
         self.assertEqual(vm.attrs, _attrs)
 
 
-class TestIndex(TestCase, VariableSubclassTestCases):
-    cls = staticmethod(Index)
+class TestXIndex(TestCase, VariableSubclassTestCases):
+    cls = staticmethod(XIndex)
 
     def test_init(self):
         with self.assertRaisesRegexp(ValueError, 'must be 1-dimensional'):
-            Index((), 0)
+            XIndex((), 0)
 
     def test_as_index(self):
         data = 0.5 * np.arange(10)
-        v = Index(['time'], data, {'foo': 'bar'})
-        self.assertTrue(pd.Index(data, name='time').identical(v.as_pandas))
+        v = XIndex(['time'], data, {'foo': 'bar'})
+        self.assertTrue(pd.Index(data, name='time').identical(v.as_index))
 
     def test_data(self):
-        x = Index('x', np.arange(3.0))
+        x = XIndex('x', np.arange(3.0))
         # data should be initially saved as an ndarray
         self.assertIs(type(x._data), NumpyArrayAdapter)
         self.assertEqual(float, x.dtype)
         self.assertArrayEqual(np.arange(3), x)
         self.assertEqual(float, x.values.dtype)
         self.assertEqual('x', x.name)
-        # after inspecting x.values, the Index will be saved as an Index
+        # after inspecting x.values, the XIndex value will be saved as an Index
         self.assertIsInstance(x._data, PandasIndexAdapter)
         with self.assertRaisesRegexp(TypeError, 'cannot be modified'):
             x[:] = 0
@@ -595,7 +595,7 @@ def test_avoid_index_dtype_inference(self):
         # verify our work-around for (pandas<0.14):
         # https://github.com/pydata/pandas/issues/6370
         data = pd.date_range('2000-01-01', periods=3).to_pydatetime()
-        t = Index('t', data)
+        t = XIndex('t', data)
         self.assertArrayEqual(t.values[:2], data[:2])
         self.assertArrayEqual(t[:2].values, data[:2])
         self.assertArrayEqual(t.values[:2], data[:2])

xray/__init__.py

@@ -1,4 +1,4 @@
-from .variable import Variable, Index, Coordinate
+from .variable import Variable, XIndex, Index, Coordinate
 from .dataset import Dataset, open_dataset
 from .data_array import DataArray, align
 

xray/common.py

@@ -116,7 +116,7 @@ def __contains__(self, key):
         return key in self._data.dimensions
 
     def __repr__(self):
-        return '\n'.join(_wrap_indent(repr(v.as_pandas), '%s: ' % k)
+        return '\n'.join(_wrap_indent(repr(v.as_index), '%s: ' % k)
                          for k, v in self.items())
 
 

xray/data_array.py

@@ -54,8 +54,8 @@ def _infer_indexes_and_dimensions(shape, indexes, dimensions):
     if indexes is None:
         indexes = [None] * len(shape)
     indexes = [idx if isinstance(idx, AbstractArray) else
-               variable.Index(dimensions[n], idx) if idx is not None else
-               variable.Index(dimensions[n], np.arange(shape[n]))
+               variable.XIndex(dimensions[n], idx) if idx is not None else
+               variable.XIndex(dimensions[n], np.arange(shape[n]))
                for n, idx in enumerate(indexes)]
 
     return indexes, dimensions
@@ -268,7 +268,7 @@ def _in_memory(self):
     def as_index(self):
         """The variable's data as a pandas.Index. Only possible for 1D arrays.
         """
-        return self.variable.to_index().as_pandas
+        return self.variable.to_xindex().as_index
 
     @property
     def dimensions(self):
@@ -342,7 +342,7 @@ def coordinates(self):
 
     @property
     def indexes(self):
-        """Dictionary-like container of xray.Index objects used for label based
+        """Dictionary-like container of xray.XIndex objects used for label based
         indexing.
 
         Keys are given by the dimensions, but list-like (integer based)
@@ -441,7 +441,7 @@ def reindex_like(self, other, copy=True):
         return self.reindex(copy=copy, **other.indexes)
 
     def reindex(self, copy=True, **indexes):
-        """Conform this object onto a new set of indxes or pandas.Index
+        """Conform this object onto a new set of indexes or pandas.Index
         objects, filling in missing values with NaN.
 
         Parameters
@@ -524,7 +524,7 @@ def groupby(self, group, squeeze=True):
 
         Parameters
         ----------
-        group : str, DataArray or Index
+        group : str, DataArray or XIndex
             Array whose unique values should be used to group this array. If a
             string, must be the name of a variable contained in this dataset.
         squeeze : boolean, optional
@@ -895,7 +895,7 @@ def align(*objects, **kwargs):
     all_indexes = defaultdict(list)
     for obj in objects:
         for k, v in iteritems(obj.indexes):
-            all_indexes[k].append(v.as_pandas)
+            all_indexes[k].append(v.as_index)
 
     # Exclude dimensions with all equal indices to avoid unnecessary reindexing
     # work.

xray/dataset.py

@@ -105,7 +105,7 @@ def _castable_to_timestamp(obj):
 
         virtual_vars = []
         for k, v in iteritems(self):
-            if ((v.dtype.kind == 'M' and isinstance(v, variable.Index))
+            if ((v.dtype.kind == 'M' and isinstance(v, variable.XIndex))
                     or (v.ndim == 0 and _castable_to_timestamp(v.values))):
                 # nb. dtype.kind == 'M' is datetime64
                 for suffix in _DATETIMEINDEX_COMPONENTS + ['season']:
@@ -126,8 +126,8 @@ def __missing__(self, key):
 
         ref_var_name, suffix = split_key
         ref_var = self[ref_var_name]
-        if isinstance(ref_var, variable.Index):
-            date = ref_var.as_pandas
+        if isinstance(ref_var, variable.XIndex):
+            date = ref_var.as_index
         elif ref_var.ndim == 0:
             date = pd.Timestamp(ref_var.values)
 
@@ -154,7 +154,7 @@ def _as_dataset_variable(name, var):
         if var.ndim != 1:
             raise ValueError('an index variable must be defined with '
                              '1-dimensional data')
-        var = var.to_index()
+        var = var.to_xindex()
     return var
 
 
@@ -165,8 +165,8 @@ def _expand_variables(raw_variables, old_variables={}, compat='identical'):
     Dataset._variables dictionary.
 
     This includes converting tuples (dimensions, data) into Variable objects,
-    converting index variables into Index objects and expanding DataArray
-    objects into Variables plus Indexs.
+    converting index variables into XIndex objects and expanding DataArray
+    objects into Variables plus XIndexes.
 
     Raises ValueError if any conflicting values are found, between any of the
     new or old variables.
@@ -277,7 +277,7 @@ class Dataset(Mapping, common.ImplementsDatasetReduce):
     and values given by DataArray objects for each variable name.
 
     One dimensional variables with name equal to their dimension are indexes,
-    which means they are saved in the dataset as `xray.Index` objects.
+    which means they are saved in the dataset as `xray.XIndex` objects.
     """
     def __init__(self, variables=None, attributes=None):
         """To load data from a file or file-like object, use the `open_dataset`
@@ -307,7 +307,7 @@ def _add_missing_indexes(self):
         """
         for dim, size in iteritems(self._dimensions):
             if dim not in self._variables:
-                coord = variable.Index(dim, np.arange(size))
+                coord = variable.XIndex(dim, np.arange(size))
                 self._variables[dim] = coord
 
     def _update_vars_and_dims(self, new_variables, needs_copy=True):
@@ -790,8 +790,8 @@ def get_fill_value_and_dtype(dtype):
                 new_var = indexes[name]
                 if not (hasattr(new_var, 'dimensions') and
                         hasattr(new_var, 'values')):
-                    new_var = variable.Index(var.dimensions, new_var,
-                                                  var.attrs, var.encoding)
+                    new_var = variable.XIndex(var.dimensions, new_var,
+                                              var.attrs, var.encoding)
                 elif copy:
                     new_var = variable.as_variable(new_var).copy()
             else:

xray/groupby.py

@@ -6,7 +6,7 @@
 
 from .common import ImplementsArrayReduce, ImplementsDatasetReduce
 from .ops import inject_reduce_methods
-from .variable import as_variable, Variable, Index
+from .variable import as_variable, Variable, XIndex
 import xray
 import numpy as np
 
@@ -66,7 +66,7 @@ def __init__(self, obj, group, squeeze=True):
         ----------
         obj : Dataset or DataArray
             Object to group.
-        group : DataArray or Index
+        group : DataArray or XIndex
             1-dimensional array with the group values.
         squeeze : boolean, optional
             If "group" is a coordinate of object, `squeeze` controls whether
@@ -106,7 +106,7 @@ def __init__(self, obj, group, squeeze=True):
         else:
             # look through group to find the unique values
             unique_values, group_indices = unique_value_groups(group)
-            unique_index = Index(group.name, unique_values)
+            unique_index = XIndex(group.name, unique_values)
 
         self.group_indices = group_indices
         self.unique_index = unique_index

xray/utils.py

@@ -91,8 +91,8 @@ def safe_cast_to_index(array):
     """
     if isinstance(array, pd.Index):
         index = array
-    elif isinstance(array, xray.Index):
-        index = array.as_pandas
+    elif isinstance(array, xray.XIndex):
+        index = array.as_index
     else:
         kwargs = {}
         if hasattr(array, 'dtype'):