BUG: Fix copy s.t. it always copies index/columns.

Only copies index/columns with `deep=True` on `BlockManager`. Plus some
tests...yay! Change copy to make views of indices.

Requires changing groupby to check whether indices are identical, rather
than comparing with `is`. Plus add tests for name checks through
everything. Also, fixes tests to use `is_()` rather than `is`

CLN: Change groupby to use 'is_' instead

Author: jtratner

doc/source/release.rst

@@ -455,6 +455,8 @@ Bug Fixes
   - Tests for fillna on empty Series (:issue:`4346`), thanks @immerrr
   - Fixed a bug where ``ValueError`` wasn't correctly raised when column names
     weren't strings (:issue:`4956`)
+  - Fixed ``copy()`` to shallow copy axes/indices as well and thereby keep
+    separate metadata. (:issue:`4202`, :issue:`4830`)
 
 pandas 0.12.0
 -------------

pandas/core/groupby.py

@@ -1988,7 +1988,7 @@ def transform(self, func, *args, **kwargs):
 
             # broadcasting
             if isinstance(res, Series):
-                if res.index is obj.index:
+                if res.index.is_(obj.index):
                     group.T.values[:] = res
                 else:
                     group.values[:] = res

pandas/core/internals.py

@@ -2334,8 +2334,12 @@ def copy(self, deep=True):
         -------
         copy : BlockManager
         """
-        new_axes = list(self.axes)
-        return self.apply('copy', axes=new_axes, deep=deep, do_integrity_check=False)
+        if deep:
+            new_axes = [ax.view() for ax in self.axes]
+        else:
+            new_axes = list(self.axes)
+        return self.apply('copy', axes=new_axes, deep=deep,
+                        ref_items=new_axes[0], do_integrity_check=False)
 
     def as_matrix(self, items=None):
         if len(self.blocks) == 0:

pandas/sparse/series.py

@@ -116,7 +116,7 @@ def __init__(self, data, index=None, sparse_index=None, kind='block',
 
             if is_sparse_array:
                 if isinstance(data, SparseSeries) and index is None:
-                    index = data.index
+                    index = data.index.view()
                 elif index is not None:
                     assert(len(index) == len(data))
 
@@ -125,14 +125,14 @@ def __init__(self, data, index=None, sparse_index=None, kind='block',
 
             elif isinstance(data, SparseSeries):
                 if index is None:
-                    index = data.index
+                    index = data.index.view()
 
                 # extract the SingleBlockManager
                 data = data._data
 
             elif isinstance(data, (Series, dict)):
                 if index is None:
-                    index = data.index
+                    index = data.index.view()
 
                 data = Series(data)
                 data, sparse_index = make_sparse(data, kind=kind,
@@ -150,7 +150,7 @@ def __init__(self, data, index=None, sparse_index=None, kind='block',
                 if dtype is not None:
                     data = data.astype(dtype)
                 if index is None:
-                    index = data.index
+                    index = data.index.view()
                 else:
                     data = data.reindex(index, copy=False)
 

pandas/sparse/tests/test_sparse.py

@@ -787,7 +787,7 @@ def test_copy(self):
         cp = self.frame.copy()
         tm.assert_isinstance(cp, SparseDataFrame)
         assert_sp_frame_equal(cp, self.frame)
-        self.assert_(cp.index is self.frame.index)
+        self.assert_(cp.index.is_(self.frame.index))
 
     def test_constructor(self):
         for col, series in compat.iteritems(self.frame):

pandas/tests/test_frame.py

@@ -1736,6 +1736,16 @@ class SafeForSparse(object):
 
     _multiprocess_can_split_ = True
 
+    def test_copy_index_name_checking(self):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+        for attr in ('index', 'columns'):
+            ind = getattr(self.frame, attr)
+            ind.name = None
+            cp = self.frame.copy()
+            getattr(cp, attr).name = 'foo'
+            self.assert_(getattr(self.frame, attr).name is None)
+
     def test_getitem_pop_assign_name(self):
         s = self.frame['A']
         self.assertEqual(s.name, 'A')
@@ -6040,16 +6050,6 @@ def test_copy(self):
         copy = self.mixed_frame.copy()
         self.assert_(copy._data is not self.mixed_frame._data)
 
-    # def test_copy_index_name_checking(self):
-    #     # don't want to be able to modify the index stored elsewhere after
-    #     # making a copy
-
-    #     self.frame.columns.name = None
-    #     cp = self.frame.copy()
-    #     cp.columns.name = 'foo'
-
-    #     self.assert_(self.frame.columns.name is None)
-
     def _check_method(self, method='pearson', check_minp=False):
         if not check_minp:
             correls = self.frame.corr(method=method)
@@ -7630,8 +7630,8 @@ def test_reindex(self):
 
         # corner cases
 
-        # Same index, copies values
-        newFrame = self.frame.reindex(self.frame.index)
+        # Same index, copies values but not index if copy=False
+        newFrame = self.frame.reindex(self.frame.index, copy=False)
         self.assert_(newFrame.index is self.frame.index)
 
         # length zero

pandas/tests/test_multilevel.py

@@ -1195,11 +1195,11 @@ def test_count(self):
 
         result = frame.count(level='b')
         expect = self.frame.count(level=1)
-        assert_frame_equal(result, expect)
+        assert_frame_equal(result, expect, check_names=False)
 
         result = frame.count(level='a')
         expect = self.frame.count(level=0)
-        assert_frame_equal(result, expect)
+        assert_frame_equal(result, expect, check_names=False)
 
         series = self.series.copy()
         series.index.names = ['a', 'b']

pandas/tests/test_panel.py

@@ -61,6 +61,13 @@ class SafeForLongAndSparse(object):
     def test_repr(self):
         foo = repr(self.panel)
 
+    def test_copy_names(self):
+        for attr in ('major_axis', 'minor_axis'):
+            getattr(self.panel, attr).name = None
+            cp = self.panel.copy()
+            getattr(cp, attr).name = 'foo'
+            self.assert_(getattr(self.panel, attr).name is None)
+
     def test_iter(self):
         tm.equalContents(list(self.panel), self.panel.items)
 

pandas/tests/test_panel4d.py

@@ -762,11 +762,6 @@ def test_reindex(self):
                                       major=self.panel4d.major_axis,
                                       minor=self.panel4d.minor_axis)
 
-        assert(result.labels is self.panel4d.labels)
-        assert(result.items is self.panel4d.items)
-        assert(result.major_axis is self.panel4d.major_axis)
-        assert(result.minor_axis is self.panel4d.minor_axis)
-
         # don't necessarily copy
         result = self.panel4d.reindex()
         assert_panel4d_equal(result,self.panel4d)

pandas/tests/test_series.py

@@ -64,14 +64,17 @@ def test_copy_name(self):
         result = self.ts.copy()
         self.assertEquals(result.name, self.ts.name)
 
-    # def test_copy_index_name_checking(self):
-    # don't want to be able to modify the index stored elsewhere after
-    # making a copy
+    def test_copy_index_name_checking(self):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
 
-    #     self.ts.index.name = None
-    #     cp = self.ts.copy()
-    #     cp.index.name = 'foo'
-    #     self.assert_(self.ts.index.name is None)
+        self.ts.index.name = None
+        self.assert_(self.ts.index.name is None)
+        self.assert_(self.ts is self.ts)
+        cp = self.ts.copy()
+        cp.index.name = 'foo'
+        print(self.ts.index.name)
+        self.assert_(self.ts.index.name is None)
 
     def test_append_preserve_name(self):
         result = self.ts[:5].append(self.ts[5:])
@@ -4270,7 +4273,8 @@ def test_align_sameindex(self):
 
     def test_reindex(self):
         identity = self.series.reindex(self.series.index)
-        self.assertEqual(id(self.series.index), id(identity.index))
+        self.assert_(np.may_share_memory(self.series.index, identity.index))
+        self.assert_(identity.index.is_(self.series.index))
 
         subIndex = self.series.index[10:20]
         subSeries = self.series.reindex(subIndex)