From 97e44a26a5d3bc822e49ae09c656c114cea14bb8 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Mon, 11 Nov 2019 07:12:48 -0700
Subject: [PATCH 01/12] Propagate indexes in _to_dataset, _from_dataset

---
 xarray/core/dataarray.py       | 42 +++++++++++++++++++++++++---------
 xarray/core/dataset.py         | 21 +++++++++++++----
 xarray/core/indexes.py         | 24 ++++++++++++++++++-
 xarray/tests/test_dataarray.py |  1 +
 4 files changed, 72 insertions(+), 16 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index 5e164f420c8..c9b99f7379e 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -50,8 +50,8 @@
 )
 from .dataset import Dataset, merge_indexes, split_indexes
 from .formatting import format_item
-from .indexes import Indexes, default_indexes
-from .merge import PANDAS_TYPES
+from .indexes import Indexes, copy_indexes, default_indexes
+from .merge import PANDAS_TYPES, _extract_indexes_from_coords
 from .options import OPTIONS
 from .utils import Default, ReprObject, _check_inplace, _default, either_dict_or_kwargs
 from .variable import (
@@ -367,6 +367,7 @@ def __init__(
             data = as_compatible_data(data)
             coords, dims = _infer_coords_and_dims(data.shape, coords, dims)
             variable = Variable(dims, data, attrs, encoding, fastpath=True)
+            indexes = dict(_extract_indexes_from_coords(coords))
 
         # These fully describe a DataArray
         self._variable = variable
@@ -377,7 +378,10 @@ def __init__(
 
         # TODO(shoyer): document this argument, once it becomes part of the
         # public interface.
-        self._indexes = indexes
+        if indexes is None or not indexes:
+            self._indexes = default_indexes(self._coords, self.dims)
+        else:
+            self._indexes = indexes
 
         self._file_obj = None
 
@@ -401,6 +405,7 @@ def _replace_maybe_drop_dims(
     ) -> "DataArray":
         if variable.dims == self.dims and variable.shape == self.shape:
             coords = self._coords.copy()
+            indexes = copy_indexes(self._indexes)
         elif variable.dims == self.dims:
             # Shape has changed (e.g. from reduce(..., keepdims=True)
             new_sizes = dict(zip(self.dims, variable.shape))
@@ -409,12 +414,19 @@ def _replace_maybe_drop_dims(
                 for k, v in self._coords.items()
                 if v.shape == tuple(new_sizes[d] for d in v.dims)
             }
+            changed_dims = [
+                k for k in variable.dims if variable.sizes[k] != self.sizes[k]
+            ]
+            indexes = copy_indexes(self._indexes, exclude=changed_dims)
         else:
             allowed_dims = set(variable.dims)
             coords = {
                 k: v for k, v in self._coords.items() if set(v.dims) <= allowed_dims
             }
-        return self._replace(variable, coords, name)
+            indexes = copy_indexes(
+                self._indexes, exclude=(set(self.dims) - allowed_dims)
+            )
+        return self._replace(variable, coords, name, indexes=indexes)
 
     def _overwrite_indexes(self, indexes: Mapping[Hashable, Any]) -> "DataArray":
         if not len(indexes):
@@ -445,6 +457,8 @@ def _from_temp_dataset(
         return self._replace(variable, coords, name, indexes=indexes)
 
     def _to_dataset_split(self, dim: Hashable) -> Dataset:
+        """ splits dataarray along dimension 'dim' """
+
         def subset(dim, label):
             array = self.loc[{dim: label}]
             if dim in array.coords:
@@ -453,11 +467,12 @@ def subset(dim, label):
             return array
 
         variables = {label: subset(dim, label) for label in self.get_index(dim)}
-
-        coords = self.coords.to_dataset()
-        if dim in coords:
-            del coords[dim]
-        return Dataset(variables, coords, self.attrs)
+        indexes = copy_indexes(self._indexes, exclude=dim)
+        coord_names = set(self._coords) - set([dim])
+        dataset = Dataset._from_vars_and_coord_names(
+            variables, coord_names, indexes=indexes, attrs=self.attrs
+        )
+        return dataset
 
     def _to_dataset_whole(
         self, name: Hashable = None, shallow_copy: bool = True
@@ -481,8 +496,12 @@ def _to_dataset_whole(
         if shallow_copy:
             for k in variables:
                 variables[k] = variables[k].copy(deep=False)
+        indexes = copy_indexes(self._indexes, deep=(not shallow_copy))
+
         coord_names = set(self._coords)
-        dataset = Dataset._from_vars_and_coord_names(variables, coord_names)
+        dataset = Dataset._from_vars_and_coord_names(
+            variables, coord_names, indexes=indexes
+        )
         return dataset
 
     def to_dataset(self, dim: Hashable = None, *, name: Hashable = None) -> Dataset:
@@ -926,7 +945,8 @@ def copy(self, deep: bool = True, data: Any = None) -> "DataArray":
         """
         variable = self.variable.copy(deep=deep, data=data)
         coords = {k: v.copy(deep=deep) for k, v in self._coords.items()}
-        return self._replace(variable, coords)
+        indexes = copy_indexes(self._indexes, deep=deep)
+        return self._replace(variable, coords, indexes=indexes)
 
     def __copy__(self) -> "DataArray":
         return self.copy(deep=False)
diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
index dc5a315e72a..f46fe9604ff 100644
--- a/xarray/core/dataset.py
+++ b/xarray/core/dataset.py
@@ -59,7 +59,13 @@
     remap_label_indexers,
 )
 from .duck_array_ops import datetime_to_numeric
-from .indexes import Indexes, default_indexes, isel_variable_and_index, roll_index
+from .indexes import (
+    Indexes,
+    copy_indexes,
+    default_indexes,
+    isel_variable_and_index,
+    roll_index,
+)
 from .merge import (
     dataset_merge_method,
     dataset_update_method,
@@ -862,8 +868,12 @@ def _construct_direct(
         return obj
 
     @classmethod
-    def _from_vars_and_coord_names(cls, variables, coord_names, attrs=None):
-        return cls._construct_direct(variables, coord_names, attrs=attrs)
+    def _from_vars_and_coord_names(
+        cls, variables, coord_names, indexes=None, attrs=None
+    ):
+        return cls._construct_direct(
+            variables, coord_names, indexes=indexes, attrs=attrs
+        )
 
     def _replace(
         self,
@@ -4308,10 +4318,13 @@ def to_array(self, dim="variable", name=None):
 
         coords = dict(self.coords)
         coords[dim] = list(self.data_vars)
+        indexes = copy_indexes(self._indexes)
 
         dims = (dim,) + broadcast_vars[0].dims
 
-        return DataArray(data, coords, dims, attrs=self.attrs, name=name)
+        return DataArray(
+            data, coords, dims, attrs=self.attrs, name=name, indexes=indexes
+        )
 
     def _to_dataframe(self, ordered_dims):
         columns = [k for k in self.variables if k not in self.dims]
diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py
index 1574f4f18df..aad22854a00 100644
--- a/xarray/core/indexes.py
+++ b/xarray/core/indexes.py
@@ -5,11 +5,12 @@
 import pandas as pd
 
 from . import formatting
+from .utils import is_scalar
 from .variable import Variable
 
 
 class Indexes(collections.abc.Mapping):
-    """Immutable proxy for Dataset or DataArrary indexes."""
+    """Mutable proxy for Dataset or DataArrary indexes."""
 
     __slots__ = ("_indexes",)
 
@@ -100,3 +101,24 @@ def roll_index(index: pd.Index, count: int, axis: int = 0) -> pd.Index:
         return index[-count:].append(index[:-count])
     else:
         return index[:]
+
+
+def copy_indexes(
+    indexes: Optional[Dict[Hashable, pd.Index]],
+    deep: bool = True,
+    exclude: Optional[Any] = None,
+) -> Optional[Dict[Hashable, pd.Index]]:
+    if exclude is None:
+        exclude = ()
+
+    if is_scalar(exclude):
+        exclude = (exclude,)
+
+    if indexes is not None:
+        new_indexes = {
+            k: v.copy(deep=deep) for k, v in indexes.items() if k not in exclude
+        }
+    else:
+        new_indexes = None  # type: ignore
+
+    return new_indexes
diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py
index 42fae2c9dd4..c7715218c4b 100644
--- a/xarray/tests/test_dataarray.py
+++ b/xarray/tests/test_dataarray.py
@@ -1229,6 +1229,7 @@ def test_coords(self):
         assert expected == actual
 
         del da.coords["x"]
+        del da.indexes["x"]
         expected = DataArray(da.values, {"y": [0, 1, 2]}, dims=["x", "y"], name="foo")
         assert_identical(da, expected)
 

From 1c9373fad55b777505e61e40e96391e655801258 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Tue, 12 Nov 2019 07:53:42 -0700
Subject: [PATCH 02/12] Make Indexes immutable again.

---
 xarray/core/groupby.py         | 3 ++-
 xarray/core/indexes.py         | 3 ---
 xarray/tests/test_dataarray.py | 3 ++-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py
index 8ae65d9b9df..65bae411c85 100644
--- a/xarray/core/groupby.py
+++ b/xarray/core/groupby.py
@@ -10,6 +10,7 @@
 from .common import ImplementsArrayReduce, ImplementsDatasetReduce
 from .concat import concat
 from .formatting import format_array_flat
+from .indexes import copy_indexes
 from .options import _get_keep_attrs
 from .pycompat import integer_types
 from .utils import (
@@ -529,7 +530,7 @@ def _maybe_unstack(self, obj):
             for dim in self._inserted_dims:
                 if dim in obj.coords:
                     del obj.coords[dim]
-                    del obj.indexes[dim]
+            obj._indexes = copy_indexes(obj._indexes, exclude=self._inserted_dims)
         return obj
 
     def fillna(self, value):
diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py
index aad22854a00..9e61cb5fd49 100644
--- a/xarray/core/indexes.py
+++ b/xarray/core/indexes.py
@@ -36,9 +36,6 @@ def __contains__(self, key):
     def __getitem__(self, key):
         return self._indexes[key]
 
-    def __delitem__(self, key):
-        del self._indexes[key]
-
     def __repr__(self):
         return formatting.indexes_repr(self)
 
diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py
index c7715218c4b..b0cb9d672d8 100644
--- a/xarray/tests/test_dataarray.py
+++ b/xarray/tests/test_dataarray.py
@@ -14,6 +14,7 @@
 from xarray.convert import from_cdms2
 from xarray.core import dtypes
 from xarray.core.common import full_like
+from xarray.core.indexes import copy_indexes
 from xarray.tests import (
     LooseVersion,
     ReturnItem,
@@ -1229,7 +1230,7 @@ def test_coords(self):
         assert expected == actual
 
         del da.coords["x"]
-        del da.indexes["x"]
+        da._indexes = copy_indexes(da._indexes, exclude="x")
         expected = DataArray(da.values, {"y": [0, 1, 2]}, dims=["x", "y"], name="foo")
         assert_identical(da, expected)
 

From 3a28951ccc4cdcd8b8b5a0dca88b33e2f7bbd518 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Tue, 12 Nov 2019 17:08:38 -0700
Subject: [PATCH 03/12] Fix DataArrayGroupby._combine.

---
 xarray/core/groupby.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py
index 65bae411c85..38b1b8c261e 100644
--- a/xarray/core/groupby.py
+++ b/xarray/core/groupby.py
@@ -733,9 +733,14 @@ def _combine(self, applied, restore_coord_dims=False, shortcut=False):
             combined = self._restore_dim_order(combined)
         if coord is not None:
             if shortcut:
-                combined._coords[coord.name] = as_variable(coord)
+                coord_var = as_variable(coord)
+                combined._coords[coord.name] = coord_var
+                if combined._indexes is not None:
+                    combined._indexes[coord.name] = coord_var.to_index()
             else:
                 combined.coords[coord.name] = coord
+                if combined._indexes is not None:
+                    combined._indexes[coord.name] = coord.to_index()
         combined = self._maybe_restore_empty_groups(combined)
         combined = self._maybe_unstack(combined)
         return combined

From b902f971ab43a2ed98092d2798c31182fe469bd3 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Tue, 12 Nov 2019 17:19:31 -0700
Subject: [PATCH 04/12] Don't create indexes by default.

---
 xarray/core/dataarray.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index c9b99f7379e..8ccb2cdbd76 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -378,10 +378,7 @@ def __init__(
 
         # TODO(shoyer): document this argument, once it becomes part of the
         # public interface.
-        if indexes is None or not indexes:
-            self._indexes = default_indexes(self._coords, self.dims)
-        else:
-            self._indexes = indexes
+        self._indexes = indexes
 
         self._file_obj = None
 

From 10e1f4d8ef67610645895b61bfedda252e016726 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Wed, 13 Nov 2019 07:48:21 -0700
Subject: [PATCH 05/12] fix to_dataset_Splt

---
 xarray/core/dataarray.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index 8ccb2cdbd76..f14bc415130 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -458,12 +458,11 @@ def _to_dataset_split(self, dim: Hashable) -> Dataset:
 
         def subset(dim, label):
             array = self.loc[{dim: label}]
-            if dim in array.coords:
-                del array.coords[dim]
             array.attrs = {}
-            return array
+            return as_variable(array)
 
         variables = {label: subset(dim, label) for label in self.get_index(dim)}
+        variables.update({k: v for k, v in self._coords.items() if k != dim})
         indexes = copy_indexes(self._indexes, exclude=dim)
         coord_names = set(self._coords) - set([dim])
         dataset = Dataset._from_vars_and_coord_names(

From 433ba711be342cbbe8f004d0c451d60e09cd7a0c Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Wed, 13 Nov 2019 07:48:44 -0700
Subject: [PATCH 06/12] undo groupby change

---
 xarray/core/groupby.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py
index 38b1b8c261e..37ab29dabd2 100644
--- a/xarray/core/groupby.py
+++ b/xarray/core/groupby.py
@@ -735,12 +735,8 @@ def _combine(self, applied, restore_coord_dims=False, shortcut=False):
             if shortcut:
                 coord_var = as_variable(coord)
                 combined._coords[coord.name] = coord_var
-                if combined._indexes is not None:
-                    combined._indexes[coord.name] = coord_var.to_index()
             else:
                 combined.coords[coord.name] = coord
-                if combined._indexes is not None:
-                    combined._indexes[coord.name] = coord.to_index()
         combined = self._maybe_restore_empty_groups(combined)
         combined = self._maybe_unstack(combined)
         return combined

From 1bffa832c216ac9dd9d82c84177f972b0a910e0b Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Wed, 13 Nov 2019 08:47:34 -0700
Subject: [PATCH 07/12] ccomment

---
 xarray/core/dataarray.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index f14bc415130..d8d2db25e29 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -367,7 +367,9 @@ def __init__(
             data = as_compatible_data(data)
             coords, dims = _infer_coords_and_dims(data.shape, coords, dims)
             variable = Variable(dims, data, attrs, encoding, fastpath=True)
-            indexes = dict(_extract_indexes_from_coords(coords))
+            indexes = dict(
+                _extract_indexes_from_coords(coords)
+            )  # needed for to_dataset
 
         # These fully describe a DataArray
         self._variable = variable

From bba1840b873ba5eebd2db1a4f3035b42beff1893 Mon Sep 17 00:00:00 2001
From: Deepak Cherian <dcherian@users.noreply.github.com>
Date: Wed, 13 Nov 2019 15:50:17 +0000
Subject: [PATCH 08/12] Update xarray/core/indexes.py

---
 xarray/core/indexes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py
index 9e61cb5fd49..3d0c1c1d2cd 100644
--- a/xarray/core/indexes.py
+++ b/xarray/core/indexes.py
@@ -10,7 +10,7 @@
 
 
 class Indexes(collections.abc.Mapping):
-    """Mutable proxy for Dataset or DataArrary indexes."""
+    """Immutable proxy for Dataset or DataArrary indexes."""
 
     __slots__ = ("_indexes",)
 

From aefa5e34168d808284d3deee4503d6a883bea082 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Sat, 16 Nov 2019 20:10:36 -0700
Subject: [PATCH 09/12] Bad idea to deep copy indexes.

---
 xarray/core/dataarray.py |  4 ++--
 xarray/core/indexes.py   | 10 ++++------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index d8d2db25e29..f0b5afdf4d5 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -494,7 +494,7 @@ def _to_dataset_whole(
         if shallow_copy:
             for k in variables:
                 variables[k] = variables[k].copy(deep=False)
-        indexes = copy_indexes(self._indexes, deep=(not shallow_copy))
+        indexes = copy_indexes(self._indexes)
 
         coord_names = set(self._coords)
         dataset = Dataset._from_vars_and_coord_names(
@@ -943,7 +943,7 @@ def copy(self, deep: bool = True, data: Any = None) -> "DataArray":
         """
         variable = self.variable.copy(deep=deep, data=data)
         coords = {k: v.copy(deep=deep) for k, v in self._coords.items()}
-        indexes = copy_indexes(self._indexes, deep=deep)
+        indexes = copy_indexes(self._indexes)
         return self._replace(variable, coords, indexes=indexes)
 
     def __copy__(self) -> "DataArray":
diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py
index 9e61cb5fd49..fc99d2201c8 100644
--- a/xarray/core/indexes.py
+++ b/xarray/core/indexes.py
@@ -101,10 +101,10 @@ def roll_index(index: pd.Index, count: int, axis: int = 0) -> pd.Index:
 
 
 def copy_indexes(
-    indexes: Optional[Dict[Hashable, pd.Index]],
-    deep: bool = True,
-    exclude: Optional[Any] = None,
+    indexes: Optional[Dict[Hashable, pd.Index]], exclude: Optional[Any] = None
 ) -> Optional[Dict[Hashable, pd.Index]]:
+    """ Creates new indexes dict from existing dict optionally excluding some dimensions.
+    """
     if exclude is None:
         exclude = ()
 
@@ -112,9 +112,7 @@ def copy_indexes(
         exclude = (exclude,)
 
     if indexes is not None:
-        new_indexes = {
-            k: v.copy(deep=deep) for k, v in indexes.items() if k not in exclude
-        }
+        new_indexes = {k: v for k, v in indexes.items() if k not in exclude}
     else:
         new_indexes = None  # type: ignore
 

From 6ae75c0521538cffb9cde9c62e118fe7ee2c0b42 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Sat, 16 Nov 2019 20:39:57 -0700
Subject: [PATCH 10/12] remove unnecessary copy_indexes calls.

---
 xarray/core/dataarray.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index 700ef2a8d16..e70c5bb33af 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -403,7 +403,7 @@ def _replace_maybe_drop_dims(
     ) -> "DataArray":
         if variable.dims == self.dims and variable.shape == self.shape:
             coords = self._coords.copy()
-            indexes = copy_indexes(self._indexes)
+            indexes = self._indexes
         elif variable.dims == self.dims:
             # Shape has changed (e.g. from reduce(..., keepdims=True)
             new_sizes = dict(zip(self.dims, variable.shape))
@@ -493,7 +493,7 @@ def _to_dataset_whole(
         if shallow_copy:
             for k in variables:
                 variables[k] = variables[k].copy(deep=False)
-        indexes = copy_indexes(self._indexes)
+        indexes = self._indexes
 
         coord_names = set(self._coords)
         dataset = Dataset._from_vars_and_coord_names(
@@ -944,7 +944,7 @@ def copy(self, deep: bool = True, data: Any = None) -> "DataArray":
         """
         variable = self.variable.copy(deep=deep, data=data)
         coords = {k: v.copy(deep=deep) for k, v in self._coords.items()}
-        indexes = copy_indexes(self._indexes)
+        indexes = self._indexes
         return self._replace(variable, coords, indexes=indexes)
 
     def __copy__(self) -> "DataArray":

From 73e8e120c5ff993855a6866075d23232e14c1e2c Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Thu, 21 Nov 2019 20:59:08 -0700
Subject: [PATCH 11/12] =?UTF-8?q?copy=5Findexes=20=E2=86=92=20propagate=5F?=
 =?UTF-8?q?indexes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 xarray/core/dataarray.py | 8 ++++----
 xarray/core/dataset.py   | 4 ++--
 xarray/core/groupby.py   | 4 ++--
 xarray/core/indexes.py   | 2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
index e70c5bb33af..05fdfa649b1 100644
--- a/xarray/core/dataarray.py
+++ b/xarray/core/dataarray.py
@@ -50,7 +50,7 @@
 )
 from .dataset import Dataset, split_indexes
 from .formatting import format_item
-from .indexes import Indexes, copy_indexes, default_indexes
+from .indexes import Indexes, propagate_indexes, default_indexes
 from .merge import PANDAS_TYPES, _extract_indexes_from_coords
 from .options import OPTIONS
 from .utils import Default, ReprObject, _check_inplace, _default, either_dict_or_kwargs
@@ -415,13 +415,13 @@ def _replace_maybe_drop_dims(
             changed_dims = [
                 k for k in variable.dims if variable.sizes[k] != self.sizes[k]
             ]
-            indexes = copy_indexes(self._indexes, exclude=changed_dims)
+            indexes = propagate_indexes(self._indexes, exclude=changed_dims)
         else:
             allowed_dims = set(variable.dims)
             coords = {
                 k: v for k, v in self._coords.items() if set(v.dims) <= allowed_dims
             }
-            indexes = copy_indexes(
+            indexes = propagate_indexes(
                 self._indexes, exclude=(set(self.dims) - allowed_dims)
             )
         return self._replace(variable, coords, name, indexes=indexes)
@@ -464,7 +464,7 @@ def subset(dim, label):
 
         variables = {label: subset(dim, label) for label in self.get_index(dim)}
         variables.update({k: v for k, v in self._coords.items() if k != dim})
-        indexes = copy_indexes(self._indexes, exclude=dim)
+        indexes = propagate_indexes(self._indexes, exclude=dim)
         coord_names = set(self._coords) - set([dim])
         dataset = Dataset._from_vars_and_coord_names(
             variables, coord_names, indexes=indexes, attrs=self.attrs
diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
index e5f9fac9036..0654123dc18 100644
--- a/xarray/core/dataset.py
+++ b/xarray/core/dataset.py
@@ -61,9 +61,9 @@
 from .duck_array_ops import datetime_to_numeric
 from .indexes import (
     Indexes,
-    copy_indexes,
     default_indexes,
     isel_variable_and_index,
+    propagate_indexes,
     roll_index,
 )
 from .merge import (
@@ -4357,7 +4357,7 @@ def to_array(self, dim="variable", name=None):
 
         coords = dict(self.coords)
         coords[dim] = list(self.data_vars)
-        indexes = copy_indexes(self._indexes)
+        indexes = propagate_indexes(self._indexes)
 
         dims = (dim,) + broadcast_vars[0].dims
 
diff --git a/xarray/core/groupby.py b/xarray/core/groupby.py
index 5606b5d754d..1caf7892672 100644
--- a/xarray/core/groupby.py
+++ b/xarray/core/groupby.py
@@ -10,7 +10,7 @@
 from .common import ImplementsArrayReduce, ImplementsDatasetReduce
 from .concat import concat
 from .formatting import format_array_flat
-from .indexes import copy_indexes
+from .indexes import propagate_indexes
 from .options import _get_keep_attrs
 from .pycompat import integer_types
 from .utils import (
@@ -530,7 +530,7 @@ def _maybe_unstack(self, obj):
             for dim in self._inserted_dims:
                 if dim in obj.coords:
                     del obj.coords[dim]
-            obj._indexes = copy_indexes(obj._indexes, exclude=self._inserted_dims)
+            obj._indexes = propagate_indexes(obj._indexes, exclude=self._inserted_dims)
         return obj
 
     def fillna(self, value):
diff --git a/xarray/core/indexes.py b/xarray/core/indexes.py
index 52899a64413..8337a0f082a 100644
--- a/xarray/core/indexes.py
+++ b/xarray/core/indexes.py
@@ -100,7 +100,7 @@ def roll_index(index: pd.Index, count: int, axis: int = 0) -> pd.Index:
         return index[:]
 
 
-def copy_indexes(
+def propagate_indexes(
     indexes: Optional[Dict[Hashable, pd.Index]], exclude: Optional[Any] = None
 ) -> Optional[Dict[Hashable, pd.Index]]:
     """ Creates new indexes dict from existing dict optionally excluding some dimensions.

From d7cab03720bd3c8021461d30a6311084f8d00061 Mon Sep 17 00:00:00 2001
From: dcherian <deepak@cherian.net>
Date: Thu, 21 Nov 2019 21:11:08 -0700
Subject: [PATCH 12/12] more renaming.

---
 xarray/tests/test_dataarray.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/xarray/tests/test_dataarray.py b/xarray/tests/test_dataarray.py
index 35d556c9ef4..b5397525a22 100644
--- a/xarray/tests/test_dataarray.py
+++ b/xarray/tests/test_dataarray.py
@@ -14,7 +14,7 @@
 from xarray.convert import from_cdms2
 from xarray.core import dtypes
 from xarray.core.common import full_like
-from xarray.core.indexes import copy_indexes
+from xarray.core.indexes import propagate_indexes
 from xarray.tests import (
     LooseVersion,
     ReturnItem,
@@ -1240,7 +1240,7 @@ def test_coords(self):
         assert expected == actual
 
         del da.coords["x"]
-        da._indexes = copy_indexes(da._indexes, exclude="x")
+        da._indexes = propagate_indexes(da._indexes, exclude="x")
         expected = DataArray(da.values, {"y": [0, 1, 2]}, dims=["x", "y"], name="foo")
         assert_identical(da, expected)