Rename DatasetArray to DataArray

Per discussion in issue #85.

Author: shoyer

doc/api.rst

@@ -32,7 +32,7 @@ Dataset contents
 ~~~~~~~~~~~~~~~~
 
 Datasets implement the mapping interface with keys given by variable names
-and values given by ``DatasetArray`` objects focused on each variable name.
+and values given by ``DataArray`` objects focused on each variable name.
 
 .. autosummary::
    :toctree: generated/
@@ -70,70 +70,70 @@ IO / Conversion
    Dataset.to_dataframe
 
 
-DatasetArray
-------------
+DataArray
+---------
 
 .. autosummary::
    :toctree: generated/
 
-   DatasetArray
+   DataArray
 
 Selecting
 ~~~~~~~~~
 
 .. autosummary::
    :toctree: generated/
 
-   DatasetArray.loc
-   DatasetArray.indexed_by
-   DatasetArray.labeled_by
-   DatasetArray.rename
-   DatasetArray.select
-   DatasetArray.unselect
-   DatasetArray.squeeze
+   DataArray.loc
+   DataArray.indexed_by
+   DataArray.labeled_by
+   DataArray.rename
+   DataArray.select
+   DataArray.unselect
+   DataArray.squeeze
 
 Group operations
 ~~~~~~~~~~~~~~~~
 
 .. autosummary::
    :toctree: generated/
 
-   DatasetArray.groupby
-   DatasetArray.concat
+   DataArray.groupby
+   DataArray.concat
 
 Manipulating data
 ~~~~~~~~~~~~~~~~~
 
 .. autosummary::
    :toctree: generated/
 
-   DatasetArray.transpose
-   DatasetArray.T
-   DatasetArray.reduce
-   DatasetArray.all
-   DatasetArray.any
-   DatasetArray.argmax
-   DatasetArray.argmin
-   DatasetArray.cumprod
-   DatasetArray.cumsum
-   DatasetArray.max
-   DatasetArray.min
-   DatasetArray.mean
-   DatasetArray.prod
-   DatasetArray.ptp
-   DatasetArray.std
-   DatasetArray.sum
-   DatasetArray.var
+   DataArray.transpose
+   DataArray.T
+   DataArray.reduce
+   DataArray.all
+   DataArray.any
+   DataArray.argmax
+   DataArray.argmin
+   DataArray.cumprod
+   DataArray.cumsum
+   DataArray.max
+   DataArray.min
+   DataArray.mean
+   DataArray.prod
+   DataArray.ptp
+   DataArray.std
+   DataArray.sum
+   DataArray.var
 
 IO / Conversion
 ~~~~~~~~~~~~~~~
 
 .. autosummary::
    :toctree: generated/
 
-   DatasetArray.to_dataframe
-   DatasetArray.to_series
-   DatasetArray.copy
+   DataArray.to_dataframe
+   DataArray.to_series
+   DataArray.copy
 
 
 XArray

doc/data-structures.rst

@@ -1,7 +1,8 @@
 Data structures
 ===============
 
-``xray``'s core data structures are the ``Dataset``, ``XArray`` and ``DatasetArray``.
+``xray``'s core data structures are the ``Dataset``, ``XArray`` and
+``DataArray``.
 
 Dataset
 -------
@@ -32,22 +33,22 @@ XArray with dimensions `('space',)` results in a new XArray with dimensions
 ``sum`` are overwritten to take a "dimension" argument instead of an "axis".
 
 XArrays are light-weight objects used as the building block for datasets.
-However, usually manipulating data in the form of a DatasetArray should be
+However, usually manipulating data in the form of a DataArray should be
 preferred (see below), because they can use more complete metadata in the full
 of other dataset variables.
 
-DatasetArray
-------------
+DataArray
+---------
 
-``DatasetArray`` is a flexible hybrid of Dataset and XArray that attempts to
-provide the best of both in a single object. Under the covers, DatasetArrays
+``DataArray`` is a flexible hybrid of Dataset and XArray that attempts to
+provide the best of both in a single object. Under the covers, DataArrays
 are simply pointers to a dataset (the ``dataset`` attribute) and the name of a
 "focus variable" in the dataset (the ``focus`` attribute), which indicates to
 which variable array operations should be applied.
 
-DatasetArray objects implement the broadcasting rules of XArray objects, but
+DataArray objects implement the broadcasting rules of XArray objects, but
 also use and maintain coordinates (aka "indices"). This means you can do
-intelligent (and fast!) label based indexing on DatasetArrays (via the
+intelligent (and fast!) label based indexing on DataArrays (via the
 ``.loc`` attribute), do flexibly split-apply-combine operations with
 ``groupby`` and also easily export them to ``pandas.DataFrame`` or
 ``pandas.Series`` objects.

doc/getting-started.rst

@@ -34,7 +34,7 @@ Let's create some ``XArray`` objects and put them in a ``Dataset``:
 This dataset contains two non-coordinate variables, ``temperature`` and
 ``avg_rain``, as well as the coordinates ``time`` and ``us_state``.
 
-We can now access the contents of ``ds`` as self-described ``DatasetArray``
+We can now access the contents of ``ds`` as self-described ``DataArray``
 objects:
 
 .. ipython:: python

src/xray/common.py

@@ -82,11 +82,10 @@ def _summarize_attributes(data):
 
 
 def array_repr(arr):
-    focus_str = ('%r ' % arr.focus) if hasattr(arr, 'focus') else ''
+    name_str = ('%r ' % arr.name) if hasattr(arr, 'name') else ''
     dim_summary = ', '.join('%s: %s' % (k, v) for k, v
                             in zip(arr.dimensions, arr.shape))
-    summary = ['<xray.%s %s(%s)>'% (type(arr).__name__, focus_str,
-                                    dim_summary)]
+    summary = ['<xray.%s %s(%s)>'% (type(arr).__name__, name_str, dim_summary)]
     if arr.size < 1e5 or arr.in_memory():
         summary.append(repr(arr.data))
     else:

src/xray/dataset.py

@@ -11,7 +11,7 @@
 import common
 import groupby
 import utils
-from dataset_array import DatasetArray
+from dataset_array import DataArray
 from utils import FrozenOrderedDict, Frozen, remap_loc_indexers
 
 date2num = nc4.date2num
@@ -99,7 +99,7 @@ class Dataset(Mapping):
     together form a self describing dataset.
 
     Dataset implements the mapping interface with keys given by variable names
-    and values given by DatasetArray objects for each variable name.
+    and values given by DataArray objects for each variable name.
 
     Note: the size of dimensions in a dataset cannot be changed.
     """
@@ -135,7 +135,7 @@ def _as_variable(self, name, var, decode_cf=False):
             var = xarray.as_xarray(var)
         except TypeError:
             raise TypeError('Dataset variables must be of type '
-                            'DatasetArray or XArray, or a sequence of the '
+                            'DataArray or XArray, or a sequence of the '
                             'form (dimensions, data[, attributes, encoding])')
         # this will unmask and rescale the data as well as convert
         # time variables to datetime indices.
@@ -278,20 +278,20 @@ def virtual_variables(self):
     def __getitem__(self, key):
         """Access the array with the given variable name.
         """
-        return DatasetArray(self, key)
+        return DataArray(self, key)
 
     def __setitem__(self, key, value):
         """Add an array to this dataset.
 
-        If value is a `DatasetArray`, call its `select()` method, rename it to
+        If value is a `DataArray`, call its `select()` method, rename it to
         `key` and merge the contents of the resulting dataset into this
         dataset.
 
         If value is an `XArray` object (or tuple of form
         `(dimensions, data[, attributes])`), add it to this dataset as a new
         variable.
         """
-        if isinstance(value, DatasetArray):
+        if isinstance(value, DataArray):
             self.merge(value.rename(key).select().dataset, inplace=True,
                        overwrite_vars=[key])
         else:
@@ -654,7 +654,7 @@ def groupby(self, group, squeeze=True):
 
         Parameters
         ----------
-        group : str or DatasetArray
+        group : str or DataArray
             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
@@ -672,7 +672,7 @@ def groupby(self, group, squeeze=True):
             # merge in the group's dataset to allow group to be a virtual
             # variable in this dataset
             ds = self.merge(self[group].dataset)
-            group = DatasetArray(ds, group)
+            group = DataArray(ds, group)
         return groupby.GroupBy(self, group.name, group, squeeze=squeeze)
 
     def squeeze(self, dimension=None):
@@ -720,7 +720,7 @@ def _add_dimension(self, dimension):
             dim_name = dimension
         else:
             dim_name, = dimension.dimensions
-            if isinstance(dimension, DatasetArray):
+            if isinstance(dimension, DataArray):
                 self.merge(dimension._unselect_nonfocus_dims().dataset,
                            inplace=True)
             else:
@@ -741,7 +741,7 @@ def concat(cls, datasets, dimension='concat_dimension', indexers=None,
             are listed in "concat_over") are expected to be equal.
         dimension : str or Array, optional
             Name of the dimension to stack along. If dimension is provided as
-            an XArray or DatasetArray, the focus of the dataset array or the
+            an XArray or DataArray, the focus of the dataset array or the
             singleton dimension of the xarray is used as the stacking dimension
             and the array is added to the returned dataset.
         indexers : None or iterable of indexers, optional

src/xray/groupby.py

@@ -50,10 +50,10 @@ class GroupBy(object):
     See Also
     --------
     XArray.groupby
-    DatasetArray.groupby
+    DataArray.groupby
     """
     def __init__(self, obj, group_name, group_coord, squeeze=True):
-        """See XArray.groupby and DatasetArray.groupby
+        """See XArray.groupby and DataArray.groupby
         """
         if group_coord.ndim != 1:
             # TODO: remove this limitation?

src/xray/utils.py

@@ -255,7 +255,7 @@ def xarray_equal(v1, v2, rtol=1e-05, atol=1e-08, check_attributes=True):
     """True if two objects have the same dimensions, attributes and data;
     otherwise False.
 
-    This function is necessary because `v1 == v2` for XArrays and DatasetArrays
+    This function is necessary because `v1 == v2` for XArrays and DataArrays
     does element-wise comparisions (like numpy.ndarrays).
     """
     def data_equiv(arr1, arr2):

src/xray/xarray.py

@@ -19,7 +19,7 @@ def as_xarray(obj, strict=True):
     """Convert an object into an XArray
 
     - If the object is already an `XArray`, return it.
-    - If the object is a `DatasetArray`, return it if `strict=False` or return
+    - If the object is a `DataArray`, return it if `strict=False` or return
       its variable if `strict=True`.
     - Otherwise, if the object has 'dimensions' and 'data' attributes, convert
       it into a new `XArray`.
@@ -29,9 +29,9 @@ def as_xarray(obj, strict=True):
     # TODO: consider extending this method to automatically handle Iris and
     # pandas objects.
     if strict and hasattr(obj, 'variable'):
-        # extract the focus XArray from DatasetArrays
+        # extract the primary XArray from DataArrays
         obj = obj.variable
-    if not isinstance(obj, (XArray, dataset_array.DatasetArray)):
+    if not isinstance(obj, (XArray, dataset_array.DataArray)):
         if hasattr(obj, 'dimensions') and hasattr(obj, 'data'):
             obj = XArray(obj.dimensions, obj.data,
                          getattr(obj, 'attributes', None),
@@ -64,7 +64,7 @@ class XArray(AbstractArray):
     """A netcdf-like variable consisting of dimensions, data and attributes
     which describe a single Array. A single XArray object is not fully described
     outside the context of its parent Dataset (if you want such a fully
-    described object, use a DatasetArray instead).
+    described object, use a DataArray instead).
     """
     def __init__(self, dims, data, attributes=None, encoding=None,
                  indexing_mode='numpy'):
@@ -494,7 +494,7 @@ def concat(cls, variables, dimension='stacked_dimension',
             Arrays to stack together. Each variable is expected to have
             matching dimensions and shape except for along the stacked
             dimension.
-        dimension : str or DatasetArray, optional
+        dimension : str or DataArray, optional
             Name of the dimension to stack along. This can either be a new
             dimension name, in which case it is added along axis=0, or an
             existing dimension name, in which case the location of the
@@ -601,7 +601,7 @@ def func(self, *args, **kwargs):
     def _binary_op(f, reflexive=False):
         @functools.wraps(f)
         def func(self, other):
-            if isinstance(other, dataset_array.DatasetArray):
+            if isinstance(other, dataset_array.DataArray):
                 return NotImplemented
             self_data, other_data, dims = _broadcast_xarray_data(self, other)
             new_data = (f(self_data, other_data)

test/test_dataset.py

@@ -12,7 +12,7 @@
 import pandas as pd
 import netCDF4 as nc4
 
-from xray import Dataset, DatasetArray, XArray, backends, open_dataset, utils
+from xray import Dataset, DataArray, XArray, backends, open_dataset, utils
 
 from . import TestCase
 
@@ -382,7 +382,7 @@ def test_merge(self):
 
     def test_getitem(self):
         data = create_test_data()
-        self.assertIsInstance(data['var1'], DatasetArray)
+        self.assertIsInstance(data['var1'], DataArray)
         self.assertXArrayEqual(data['var1'], data.variables['var1'])
         self.assertIs(data['var1'].dataset, data)