Consistent names: always use 'attrs' rather than 'attributes'

Related: pydata#190

Author: shoyer

test/test_data_array.py

@@ -160,7 +160,7 @@ def test_constructor(self):
         expected = Dataset({'foo': (['dim_0', 'dim_1'], data)})['foo']
         self.assertDataArrayIdentical(expected, actual)
 
-        actual = DataArray(data, dimensions=['x', 'y'], attributes={'bar': 2})
+        actual = DataArray(data, dimensions=['x', 'y'], attrs={'bar': 2})
         expected = Dataset({None: (['x', 'y'], data, {'bar': 2})})[None]
         self.assertDataArrayIdentical(expected, actual)
 
@@ -173,7 +173,7 @@ def test_constructor_from_self_described(self):
         expected = DataArray(data,
                              coordinates={'x': ['a', 'b'], 'y': [-1, -2]},
                              dimensions=['x', 'y'], name='foobar',
-                             attributes={'bar': 2}, encoding={'foo': 3})
+                             attrs={'bar': 2}, encoding={'foo': 3})
         actual = DataArray(expected)
         self.assertDataArrayIdentical(expected, actual)
 

test/test_variable.py

@@ -339,9 +339,9 @@ def test_equals_and_identical(self):
         d = np.random.rand(10, 3)
         d[0, 0] = np.nan
         v1 = Variable(('dim1', 'dim2'), data=d,
-                       attributes={'att1': 3, 'att2': [1, 2, 3]})
+                       attrs={'att1': 3, 'att2': [1, 2, 3]})
         v2 = Variable(('dim1', 'dim2'), data=d,
-                       attributes={'att1': 3, 'att2': [1, 2, 3]})
+                       attrs={'att1': 3, 'att2': [1, 2, 3]})
         self.assertTrue(v1.equals(v2))
         self.assertTrue(v1.identical(v2))
 

xray/data_array.py

@@ -153,7 +153,7 @@ class DataArray(AbstractArray):
         Dictionary of Coordinate objects that label values along each dimension.
     """
     def __init__(self, data=None, coordinates=None, dimensions=None, name=None,
-                 attributes=None, encoding=None):
+                 attrs=None, encoding=None):
         """
         Parameters
         ----------
@@ -175,7 +175,7 @@ def __init__(self, data=None, coordinates=None, dimensions=None, name=None,
             ``['dim_0', ... 'dim_n']``.
         name : str or None, optional
             Name of this array.
-        attributes : dict_like or None, optional
+        attrs : dict_like or None, optional
             Attributes to assign to the new variable. By default, an empty
             attribute dictionary is initialized.
         encoding : dict_like or None, optional
@@ -200,8 +200,8 @@ def __init__(self, data=None, coordinates=None, dimensions=None, name=None,
             dimensions = getattr(data, 'dimensions', None)
         if name is None:
             name = getattr(data, 'name', None)
-        if attributes is None:
-            attributes = getattr(data, 'attrs', None)
+        if attrs is None:
+            attrs = getattr(data, 'attrs', None)
         if encoding is None:
             encoding = getattr(data, 'encoding', None)
 
@@ -210,7 +210,7 @@ def __init__(self, data=None, coordinates=None, dimensions=None, name=None,
             data.shape, coordinates, dimensions)
         variables = OrderedDict((var.name, var) for var in coordinates)
         variables[name] = variable.Variable(
-            dimensions, data, attributes, encoding)
+            dimensions, data, attrs, encoding)
         dataset = xray.Dataset(variables)
 
         self._dataset = dataset

xray/dataset.py

@@ -289,29 +289,29 @@ class Dataset(Mapping, common.ImplementsDatasetReduce):
     coordinates, which means they are saved in the dataset as `xray.Coordinate`
     objects.
     """
-    def __init__(self, variables=None, attributes=None):
+    def __init__(self, variables=None, attrs=None):
         """To load data from a file or file-like object, use the `open_dataset`
         function.
 
         Parameters
         ----------
         variables : dict-like, optional
             A mapping from variable names to `DataArray` objets, `Variable`
-            objects or sequences of the form `(dimensions, data[, attributes])`
+            objects or sequences of the form `(dimensions, data[, attrs])`
             which can be used as arguments to create a new `Variable`. Each
             dimension must have the same length in all variables in which it
             appears.
-        attributes : dict-like, optional
+        attrs : dict-like, optional
             Global attributes to save on this dataset.
         """
         self._variables = VariablesDict()
         self._dimensions = SortedKeysDict()
-        self._attributes = OrderedDict()
+        self._attrs = OrderedDict()
         self._file_obj = None
         if variables is not None:
             self._set_init_vars_and_dims(variables)
-        if attributes is not None:
-            self._attributes.update(attributes)
+        if attrs is not None:
+            self._attrs.update(attrs)
 
     def _add_missing_coordinates(self):
         """Add missing coordinate variables IN-PLACE to the variables dict
@@ -403,22 +403,22 @@ def variables(self):
     @property
     def attributes(self):
         utils.alias_warning('attributes', 'attrs', 3)
-        return self._attributes
+        return self._attrs
 
     @attributes.setter
     def attributes(self, value):
         utils.alias_warning('attributes', 'attrs', 3)
-        self._attributes = OrderedDict(value)
+        self._attrs = OrderedDict(value)
 
     @property
     def attrs(self):
         """Dictionary of global attributes on this dataset
         """
-        return self._attributes
+        return self._attrs
 
     @attrs.setter
     def attrs(self, value):
-        self._attributes = OrderedDict(value)
+        self._attrs = OrderedDict(value)
 
     @property
     def dimensions(self):
@@ -458,7 +458,7 @@ def copy(self, deep=False):
         obj = self.__new__(type(self))
         obj._variables = variables
         obj._dimensions = self._dimensions.copy()
-        obj._attributes = self._attributes.copy()
+        obj._attrs = self._attrs.copy()
         obj._file_obj = None
         return obj
 
@@ -516,7 +516,7 @@ def __setitem__(self, key, value):
         dataset.
 
         If value is an `Variable` object (or tuple of form
-        `(dimensions, data[, attributes])`), add it to this dataset as a new
+        `(dimensions, data[, attrs])`), add it to this dataset as a new
         variable.
         """
         self.merge({key: value}, inplace=True, overwrite_vars=[key])
@@ -1150,7 +1150,7 @@ def reduce(self, func, dimension=None, keep_attrs=False, **kwargs):
 
         attrs = self.attrs if keep_attrs else {}
 
-        return Dataset(variables=variables, attributes=attrs)
+        return Dataset(variables, attrs)
 
     def apply(self, func, to=None, keep_attrs=False, **kwargs):
         """Apply a function over noncoordinates in this dataset.

xray/variable.py

@@ -191,17 +191,17 @@ class Variable(AbstractArray):
     described outside the context of its parent Dataset (if you want such a
     fully described object, use a DataArray instead).
     """
-    def __init__(self, dims, data, attributes=None, encoding=None):
+    def __init__(self, dimensions, data, attrs=None, encoding=None):
         """
         Parameters
         ----------
-        dims : str or sequence of str
+        dimensions : str or sequence of str
             Name(s) of the the data dimension(s). Must be either a string (only
             for 1D data) or a sequence of strings with length equal to the
             number of dimensions.
         data : array_like
             Data array which supports numpy-like data access.
-        attributes : dict_like or None, optional
+        attrs : dict_like or None, optional
             Attributes to assign to the new variable. If None (default), an
             empty attribute dictionary is initialized.
         encoding : dict_like or None, optional
@@ -212,10 +212,10 @@ def __init__(self, dims, data, attributes=None, encoding=None):
             unrecognized encoding items.
         """
         self._data = _as_compatible_data(data)
-        self._dimensions = self._parse_dimensions(dims)
-        if attributes is None:
-            attributes = {}
-        self._attributes = OrderedDict(attributes)
+        self._dimensions = self._parse_dimensions(dimensions)
+        if attrs is None:
+            attrs = {}
+        self._attrs = OrderedDict(attrs)
         self._encoding = dict({} if encoding is None else encoding)
 
     @property
@@ -361,11 +361,11 @@ def attributes(self, value):
     def attrs(self):
         """Dictionary of local attributes on this variable.
         """
-        return self._attributes
+        return self._attrs
 
     @attrs.setter
     def attrs(self, value):
-        self._attributes = OrderedDict(value)
+        self._attrs = OrderedDict(value)
 
     @property
     def encoding(self):
@@ -533,7 +533,7 @@ def reduce(self, func, dimension=None, axis=None, keep_attrs=False,
 
         attrs = self.attrs if keep_attrs else {}
 
-        return Variable(dims, data, attributes=attrs)
+        return Variable(dims, data, attrs=attrs)
 
     @classmethod
     def concat(cls, variables, dimension='stacked_dimension',
@@ -717,13 +717,13 @@ class Coordinate(Variable):
     """
     _cache_data_class = PandasIndexAdapter
 
-    def __init__(self, name, data, attributes=None, encoding=None):
+    def __init__(self, name, data, attrs=None, encoding=None):
         if isinstance(data, pd.MultiIndex):
             raise NotImplementedError(
                 'no support yet for using a pandas.MultiIndex in an '
                 'xray.Coordinate')
 
-        super(Coordinate, self).__init__(name, data, attributes, encoding)
+        super(Coordinate, self).__init__(name, data, attrs, encoding)
         if self.ndim != 1:
             raise ValueError('%s objects must be 1-dimensional' %
                              type(self).__name__)