Rename xray.Coordinate to xray.Index

Fixes #142.

Author: shoyer

doc/api.rst

@@ -20,8 +20,8 @@ Attributes and underlying data
 .. autosummary::
    :toctree: generated/
 
-   Dataset.coordinates
-   Dataset.noncoordinates
+   Dataset.indexes
+   Dataset.nonindexes
    Dataset.dimensions
    Dataset.attrs
 
@@ -143,7 +143,7 @@ Attributes and underlying data
 
    DataArray.values
    DataArray.as_index
-   DataArray.coordinates
+   DataArray.indexes
    DataArray.name
    DataArray.dataset
    DataArray.attrs

test/__init__.py

@@ -109,24 +109,24 @@ def assertDatasetAllClose(self, d1, d2, rtol=1e-05, atol=1e-08):
             v2 = d2.variables[k]
             self.assertVariableAllClose(v1, v2, rtol=rtol, atol=atol)
 
-    def assertCoordsEqual(self, d1, d2):
-        self.assertEqual(sorted(d1.coordinates), sorted(d2.coordinates))
-        for k in d1.coordinates:
-            v1 = d1.coordinates[k]
-            v2 = d2.coordinates[k]
+    def assertIndexesEqual(self, d1, d2):
+        self.assertEqual(sorted(d1.indexes), sorted(d2.indexes))
+        for k in d1.indexes:
+            v1 = d1.indexes[k]
+            v2 = d2.indexes[k]
             self.assertVariableEqual(v1, v2)
 
     def assertDataArrayEqual(self, ar1, ar2):
         self.assertVariableEqual(ar1, ar2)
-        self.assertCoordsEqual(ar1, ar2)
+        self.assertIndexesEqual(ar1, ar2)
 
     def assertDataArrayIdentical(self, ar1, ar2):
         self.assertEqual(ar1.name, ar2.name)
         self.assertDatasetIdentical(ar1.dataset, ar2.dataset)
 
     def assertDataArrayAllClose(self, ar1, ar2, rtol=1e-05, atol=1e-08):
         self.assertVariableAllClose(ar1, ar2, rtol=rtol, atol=atol)
-        self.assertCoordsEqual(ar1, ar2)
+        self.assertIndexesEqual(ar1, ar2)
 
 
 class ReturnItem(object):

test/test_data_array.py

@@ -38,7 +38,7 @@ def test_repr(self):
         <xray.DataArray 'my_variable' (time: 2, x: 3)>
         array([[1, 2, 3],
                [4, 5, 6]])
-        Coordinates:
+        Indexes:
             time: Int64Index([0, 1], dtype='int64')
             x: Int64Index([0, 1, 2], dtype='int64')
         Linked dataset variables:
@@ -57,9 +57,9 @@ def test_properties(self):
             self.assertEqual(getattr(self.dv, attr), getattr(self.v, attr))
         self.assertEqual(len(self.dv), len(self.v))
         self.assertVariableEqual(self.dv, self.v)
-        self.assertEqual(list(self.dv.coordinates), list(self.ds.coordinates))
-        for k, v in iteritems(self.dv.coordinates):
-            self.assertArrayEqual(v, self.ds.coordinates[k])
+        self.assertEqual(list(self.dv.indexes), list(self.ds.indexes))
+        for k, v in iteritems(self.dv.indexes):
+            self.assertArrayEqual(v, self.ds.indexes[k])
         with self.assertRaises(AttributeError):
             self.dv.name = 'bar'
         with self.assertRaises(AttributeError):
@@ -162,7 +162,7 @@ def test_constructor_from_self_described(self):
 
         panel = pd.Panel({0: frame})
         actual = DataArray(panel)
-        expected = DataArray([data], expected.coordinates, ['dim_0', 'x', 'y'])
+        expected = DataArray([data], expected.indexes, ['dim_0', 'x', 'y'])
         self.assertDataArrayIdentical(expected, actual)
 
         expected = DataArray(['a', 'b'], name='foo')

test/test_dataset.py

@@ -73,16 +73,16 @@ def test_repr(self):
         data = create_test_data()
         expected = dedent("""
         <xray.Dataset>
-        Dimensions:     (dim1: 100, dim2: 50, dim3: 10, time: 20)
-        Coordinates:
-            dim1             X
-            dim2                        X
-            dim3                                  X
-            time                                            X
-        Noncoordinates:
-            var1             0          1
-            var2             0          1
-            var3             1                    0
+        Dimensions:  (dim1: 100, dim2: 50, dim3: 10, time: 20)
+        Indexes:
+            dim1          X
+            dim2                     X
+            dim3                               X
+            time                                         X
+        Non-indexes:
+            var1          0          1
+            var2          0          1
+            var3          1                    0
         Attributes:
             Empty
         """).strip()
@@ -91,10 +91,10 @@ def test_repr(self):
 
         expected = dedent("""
         <xray.Dataset>
-        Dimensions:     ()
-        Coordinates:
+        Dimensions:  ()
+        Indexes:
             None
-        Noncoordinates:
+        Non-indexes:
             None
         Attributes:
             Empty
@@ -130,14 +130,14 @@ def test_variable(self):
         with self.assertRaises(ValueError):
             a['qux'] = (('time', 'x'), d.T)
 
-    def test_coordinate(self):
+    def test_indexes(self):
         a = Dataset()
         vec = np.random.random((10,))
         attributes = {'foo': 'bar'}
         a['x'] = ('x', vec, attributes)
-        self.assertTrue('x' in a.coordinates)
-        self.assertIsInstance(a.coordinates['x'].as_index, pd.Index)
-        self.assertVariableEqual(a.coordinates['x'], a.variables['x'])
+        self.assertTrue('x' in a.indexes)
+        self.assertIsInstance(a.indexes['x'].as_pandas, pd.Index)
+        self.assertVariableEqual(a.indexes['x'], a.variables['x'])
         b = Dataset()
         b['x'] = ('x', vec, attributes)
         self.assertVariableEqual(a['x'], b['x'])
@@ -213,18 +213,18 @@ def test_indexed(self):
 
         ret = data.indexed(dim1=0)
         self.assertEqual({'time': 20, 'dim2': 50, 'dim3': 10}, ret.dimensions)
-        self.assertItemsEqual(list(data.noncoordinates) + ['dim1'],
-                              ret.noncoordinates)
+        self.assertItemsEqual(list(data.nonindexes) + ['dim1'],
+                              ret.nonindexes)
 
         ret = data.indexed(time=slice(2), dim1=0, dim2=slice(5))
         self.assertEqual({'time': 2, 'dim2': 5, 'dim3': 10}, ret.dimensions)
-        self.assertItemsEqual(list(data.noncoordinates) + ['dim1'],
-                              ret.noncoordinates)
+        self.assertItemsEqual(list(data.nonindexes) + ['dim1'],
+                              ret.nonindexes)
 
         ret = data.indexed(time=0, dim1=0, dim2=slice(5))
         self.assertItemsEqual({'dim2': 5, 'dim3': 10}, ret.dimensions)
-        self.assertItemsEqual(list(data.noncoordinates) + ['dim1', 'time'],
-                              ret.noncoordinates)
+        self.assertItemsEqual(list(data.nonindexes) + ['dim1', 'time'],
+                              ret.nonindexes)
 
     def test_labeled(self):
         data = create_test_data()
@@ -440,7 +440,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_index.month)
+                              data.variables['time'].as_pandas.month)
         self.assertArrayEqual(data['time.season'].values, 1)
         # test virtual variable math
         self.assertArrayEqual(data['time.dayofyear'] + 1, 2 + np.arange(20))
@@ -670,10 +670,10 @@ def test_lazy_load(self):
     def test_reduce(self):
         data = create_test_data()
 
-        self.assertEqual(len(data.mean().coordinates), 0)
+        self.assertEqual(len(data.mean().indexes), 0)
 
         expected = data.max()
-        for var in data.noncoordinates:
+        for var in data.nonindexes:
             expected = data[var].max()
             actual = expected[var]
             self.assertDataArrayEqual(expected, actual)

test/test_indexing.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from xray import indexing, variable, Dataset, Variable, Coordinate
+from xray import indexing, variable, Dataset, Variable, Index
 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 = Coordinate('x', [1, 2, 3])
+        coord = Index('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 (Coordinate, as_variable, NumpyArrayAdapter,
+from xray.variable import (Index, as_variable, NumpyArrayAdapter,
                            PandasIndexAdapter, _as_compatible_data)
 from xray.pycompat import PY3
 
@@ -164,16 +164,16 @@ def test_1d_math(self):
         self.assertArrayEqual((v * w).values, x * y)
         # something complicated
         self.assertArrayEqual((v ** 2 * w - 1 + x).values, x ** 2 * y - 1 + x)
-        # make sure dtype is preserved (for Coordinates)
+        # make sure dtype is preserved (for Index objects)
         self.assertEqual(float, (+v).dtype)
         self.assertEqual(float, (+v).values.dtype)
         self.assertEqual(float, (0 + v).dtype)
         self.assertEqual(float, (0 + v).values.dtype)
         # check types of returned data
         self.assertIsInstance(+v, Variable)
-        self.assertNotIsInstance(+v, Coordinate)
+        self.assertNotIsInstance(+v, Index)
         self.assertIsInstance(0 + v, Variable)
-        self.assertNotIsInstance(0 + v, Coordinate)
+        self.assertNotIsInstance(0 + v, Index)
 
     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), Coordinate)
+        self.assertNotIsInstance(np.sin(v), Index)
 
     def example_1d_objects(self):
         for data in [range(3),
@@ -563,27 +563,27 @@ def test_reduce_keep_attrs(self):
         self.assertEqual(vm.attrs, _attrs)
 
 
-class TestCoordinate(TestCase, VariableSubclassTestCases):
-    cls = staticmethod(Coordinate)
+class TestIndex(TestCase, VariableSubclassTestCases):
+    cls = staticmethod(Index)
 
     def test_init(self):
         with self.assertRaisesRegexp(ValueError, 'must be 1-dimensional'):
-            Coordinate((), 0)
+            Index((), 0)
 
     def test_as_index(self):
         data = 0.5 * np.arange(10)
-        v = Coordinate(['time'], data, {'foo': 'bar'})
-        self.assertTrue(pd.Index(data, name='time').identical(v.as_index))
+        v = Index(['time'], data, {'foo': 'bar'})
+        self.assertTrue(pd.Index(data, name='time').identical(v.as_pandas))
 
     def test_data(self):
-        x = Coordinate('x', np.arange(3.0))
+        x = Index('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 Coordinate will be saved as an Index
+        # after inspecting x.values, the Index will be saved as an Index
         self.assertIsInstance(x._data, PandasIndexAdapter)
         with self.assertRaisesRegexp(TypeError, 'cannot be modified'):
             x[:] = 0
@@ -592,7 +592,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 = Coordinate('t', data)
+        t = Index('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, Coordinate
+from .variable import Variable, Index, Coordinate
 from .dataset import Dataset, open_dataset
 from .data_array import DataArray, align
 

xray/common.py

@@ -142,13 +142,13 @@ def array_repr(arr):
         summary.append(repr(arr.values))
     else:
         summary.append('[%s values with dtype=%s]' % (arr.size, arr.dtype))
-    if hasattr(arr, 'coordinates'):
-        if arr.coordinates:
-            summary.append('Coordinates:')
-            for k, v in arr.coordinates.items():
-                summary.append(_wrap_indent(repr(v.as_index), '    %s: ' % k))
+    if hasattr(arr, 'dataset'):
+        if arr.indexes:
+            summary.append('Indexes:')
+            for k, v in arr.indexes.items():
+                summary.append(_wrap_indent(repr(v.as_pandas), '    %s: ' % k))
         other_vars = [k for k in arr.dataset
-                      if k not in arr.coordinates and k != arr.name]
+                      if k not in arr.indexes and k != arr.name]
         if other_vars:
             summary.append('Linked dataset variables:')
             summary.append('    ' + ', '.join(other_vars))
@@ -172,7 +172,7 @@ def dataset_repr(ds):
     summary = ['<xray.%s>' % type(ds).__name__]
 
     max_name_length = max(len(k) for k in ds.variables) if ds else 0
-    first_col_width = max(4 + max_name_length, 16)
+    first_col_width = max(4 + max_name_length, 13)
     coords_str = pretty_print('Dimensions:', first_col_width)
     all_dim_strings = ['%s: %s' % (k, v) for k, v in iteritems(ds.dimensions)]
     summary.append('%s(%s)' % (coords_str, ', '.join(all_dim_strings)))
@@ -201,11 +201,11 @@ def summarize_variables(variables, not_found=' ', found=int):
         else:
             return ['    None']
 
-    summary.append('Coordinates:')
-    summary.extend(summarize_variables(ds.coordinates, ' ', 'X'))
+    summary.append('Indexes:')
+    summary.extend(summarize_variables(ds.indexes, ' ', 'X'))
 
-    summary.append('Noncoordinates:')
-    summary.extend(summarize_variables(ds.noncoordinates, ' ', int))
+    summary.append('Non-indexes:')
+    summary.extend(summarize_variables(ds.nonindexes, ' ', int))
 
     summary.append('Attributes:\n%s' % _summarize_attributes(ds))