TST: Check series names

Author: sinhrks

pandas/computation/tests/test_eval.py

@@ -1207,7 +1207,9 @@ def f():
             a = 1
             old_a = df.a.copy()
             df.eval('a = a + b')
-            assert_series_equal(old_a + df.b, df.a)
+            result = old_a + df.b
+            assert_series_equal(result, df.a, check_names=False)
+            self.assertTrue(result.name is None)
 
         f()
 
@@ -1251,7 +1253,7 @@ def test_date_boolean(self):
         res = self.eval('df.dates1 < 20130101', local_dict={'df': df},
                         engine=self.engine, parser=self.parser)
         expec = df.dates1 < '20130101'
-        assert_series_equal(res, expec)
+        assert_series_equal(res, expec, check_names=False)
 
     def test_simple_in_ops(self):
         if self.parser != 'python':

pandas/io/tests/test_json/test_pandas.py

@@ -409,12 +409,10 @@ def _check_orient(series, orient, dtype=None, numpy=False):
             if orient == "records" or orient == "values":
                 assert_almost_equal(series.values, unser.values)
             else:
-                try:
-                    assert_series_equal(series, unser)
-                except:
-                    raise
                 if orient == "split":
-                    self.assertEqual(series.name, unser.name)
+                    assert_series_equal(series, unser)
+                else:
+                    assert_series_equal(series, unser, check_names=False)
 
         def _check_all_orients(series, dtype=None):
             _check_orient(series, "columns", dtype=dtype)
@@ -491,7 +489,8 @@ def test_axis_dates(self):
         # series
         json = self.ts.to_json()
         result = read_json(json, typ='series')
-        assert_series_equal(result, self.ts)
+        assert_series_equal(result, self.ts, check_names=False)
+        self.assertTrue(result.name is None)
 
     def test_convert_dates(self):
 

pandas/io/tests/test_parsers.py

@@ -272,7 +272,8 @@ def test_squeeze(self):
 b,2
 c,3
 """
-        expected = Series([1, 2, 3], index=Index(['a', 'b', 'c'], name=0))
+        idx = Index(['a', 'b', 'c'], name=0)
+        expected = Series([1, 2, 3], name=1, index=idx)
         result = self.read_table(StringIO(data), sep=',', index_col=0,
                                  header=None, squeeze=True)
         tm.assert_isinstance(result, Series)
@@ -2638,7 +2639,7 @@ def test_iteration_open_handle(self):
                 result = read_table(f, squeeze=True, header=None,
                                     engine='python')
 
-                expected = Series(['DDD', 'EEE', 'FFF', 'GGG'])
+                expected = Series(['DDD', 'EEE', 'FFF', 'GGG'], name=0)
                 tm.assert_series_equal(result, expected)
 
     def test_iterator(self):

pandas/io/tests/test_sql.py

@@ -1256,7 +1256,7 @@ def test_transactions(self):
         self._transaction_test()
 
     def test_get_schema_create_table(self):
-        # Use a dataframe without a bool column, since MySQL converts bool to 
+        # Use a dataframe without a bool column, since MySQL converts bool to
         # TINYINT (which read_sql_table returns as an int and causes a dtype
         # mismatch)
 
@@ -2025,7 +2025,7 @@ def test_tquery(self):
         frame = tm.makeTimeDataFrame()
         sql.write_frame(frame, name='test_table', con=self.db)
         result = sql.tquery("select A from test_table", self.db)
-        expected = Series(frame.A, frame.index) # not to have name
+        expected = Series(frame.A.values, frame.index) # not to have name
         result = Series(result, frame.index)
         tm.assert_series_equal(result, expected)
 
@@ -2370,7 +2370,7 @@ def test_tquery(self):
         cur.execute(drop_sql)
         sql.write_frame(frame, name='test_table', con=self.db, flavor='mysql')
         result = sql.tquery("select A from test_table", self.db)
-        expected = Series(frame.A, frame.index) # not to have name
+        expected = Series(frame.A.values, frame.index) # not to have name
         result = Series(result, frame.index)
         tm.assert_series_equal(result, expected)
 

pandas/sparse/tests/test_sparse.py

@@ -12,7 +12,8 @@
 dec = np.testing.dec
 
 from pandas.util.testing import (assert_almost_equal, assert_series_equal,
-                                 assert_frame_equal, assert_panel_equal, assertRaisesRegexp, assert_array_equal)
+                                 assert_frame_equal, assert_panel_equal, assertRaisesRegexp,
+                                 assert_array_equal, assert_attr_equal)
 from numpy.testing import assert_equal
 
 from pandas import Series, DataFrame, bdate_range, Panel, MultiIndex
@@ -76,9 +77,11 @@ def _test_data2_zero():
     return arr, index
 
 
-def assert_sp_series_equal(a, b, exact_indices=True):
+def assert_sp_series_equal(a, b, exact_indices=True, check_names=True):
     assert(a.index.equals(b.index))
     assert_sp_array_equal(a, b)
+    if check_names:
+        assert_attr_equal('name', a, b)
 
 
 def assert_sp_frame_equal(left, right, exact_indices=True):
@@ -130,7 +133,6 @@ def setUp(self):
 
         self.bseries = SparseSeries(arr, index=index, kind='block',
                                     name='bseries')
-
         self.ts = self.bseries
 
         self.btseries = SparseSeries(arr, index=date_index, kind='block')
@@ -168,10 +170,10 @@ def test_construct_DataFrame_with_sp_series(self):
         df.dtypes
         str(df)
 
-        assert_sp_series_equal(df['col'], self.bseries)
+        assert_sp_series_equal(df['col'], self.bseries, check_names=False)
 
         result = df.iloc[:, 0]
-        assert_sp_series_equal(result, self.bseries)
+        assert_sp_series_equal(result, self.bseries, check_names=False)
 
         # blocking
         expected = Series({'col': 'float64:sparse'})
@@ -209,14 +211,16 @@ def test_dense_to_sparse(self):
         bseries = series.to_sparse(kind='block')
         iseries = series.to_sparse(kind='integer')
         assert_sp_series_equal(bseries, self.bseries)
-        assert_sp_series_equal(iseries, self.iseries)
+        assert_sp_series_equal(iseries, self.iseries, check_names=False)
+        self.assertEqual(iseries.name, self.bseries.name)
 
         # non-NaN fill value
         series = self.zbseries.to_dense()
         zbseries = series.to_sparse(kind='block', fill_value=0)
         ziseries = series.to_sparse(kind='integer', fill_value=0)
         assert_sp_series_equal(zbseries, self.zbseries)
-        assert_sp_series_equal(ziseries, self.ziseries)
+        assert_sp_series_equal(ziseries, self.ziseries, check_names=False)
+        self.assertEqual(ziseries.name, self.zbseries.name)
 
     def test_to_dense_preserve_name(self):
         assert(self.bseries.name is not None)
@@ -244,7 +248,7 @@ def _check_const(sparse, name):
 
             # use passed name
             result = SparseSeries(sparse, name='x')
-            assert_sp_series_equal(result, sparse)
+            assert_sp_series_equal(result, sparse, check_names=False)
             self.assertEqual(result.name, 'x')
 
         _check_const(self.bseries, 'bseries')
@@ -1301,7 +1305,7 @@ def _check_frame(frame):
             # insert SparseSeries
             frame['E'] = frame['A']
             tm.assert_isinstance(frame['E'], SparseSeries)
-            assert_sp_series_equal(frame['E'], frame['A'])
+            assert_sp_series_equal(frame['E'], frame['A'], check_names=False)
 
             # insert SparseSeries differently-indexed
             to_insert = frame['A'][::2]
@@ -1315,13 +1319,14 @@ def _check_frame(frame):
             # insert Series
             frame['F'] = frame['A'].to_dense()
             tm.assert_isinstance(frame['F'], SparseSeries)
-            assert_sp_series_equal(frame['F'], frame['A'])
+            assert_sp_series_equal(frame['F'], frame['A'], check_names=False)
 
             # insert Series differently-indexed
             to_insert = frame['A'].to_dense()[::2]
             frame['G'] = to_insert
             expected = to_insert.reindex(
                 frame.index).fillna(frame.default_fill_value)
+            expected.name = 'G'
             assert_series_equal(frame['G'].to_dense(), expected)
 
             # insert ndarray
@@ -1349,18 +1354,18 @@ def _check_frame(frame):
 
     def test_setitem_corner(self):
         self.frame['a'] = self.frame['B']
-        assert_sp_series_equal(self.frame['a'], self.frame['B'])
+        assert_sp_series_equal(self.frame['a'], self.frame['B'], check_names=False)
 
     def test_setitem_array(self):
         arr = self.frame['B']
 
         self.frame['E'] = arr
-        assert_sp_series_equal(self.frame['E'], self.frame['B'])
+        assert_sp_series_equal(self.frame['E'], self.frame['B'], check_names=False)
 
         self.frame['F'] = arr[:-1]
         index = self.frame.index[:-1]
-        assert_sp_series_equal(
-            self.frame['E'].reindex(index), self.frame['F'].reindex(index))
+        assert_sp_series_equal(self.frame['E'].reindex(index),
+                               self.frame['F'].reindex(index), check_names=False)
 
     def test_delitem(self):
         A = self.frame['A']

pandas/tests/test_categorical.py

@@ -1233,7 +1233,7 @@ def test_codes_dtypes(self):
     def test_basic(self):
 
         # test basic creation / coercion of categoricals
-        s = Series(self.factor,name='A')
+        s = Series(self.factor, name='A')
         self.assertEqual(s.dtype,'category')
         self.assertEqual(len(s),len(self.factor))
         str(s.values)
@@ -1260,8 +1260,9 @@ def test_basic(self):
         df = DataFrame({'A' : s, 'B' : s, 'C' : 1})
         result1 = df['A']
         result2 = df['B']
-        tm.assert_series_equal(result1,s)
-        tm.assert_series_equal(result2,s)
+        tm.assert_series_equal(result1, s)
+        tm.assert_series_equal(result2, s, check_names=False)
+        self.assertEqual(result2.name, 'B')
         self.assertEqual(len(df),len(self.factor))
         str(df.values)
         str(df)
@@ -1344,23 +1345,23 @@ def test_construction_frame(self):
         # GH8626
 
         # dict creation
-        df = DataFrame({ 'A' : list('abc') },dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df['A'],expected)
+        df = DataFrame({ 'A' : list('abc') }, dtype='category')
+        expected = Series(list('abc'), dtype='category', name='A')
+        tm.assert_series_equal(df['A'], expected)
 
         # to_frame
-        s = Series(list('abc'),dtype='category')
+        s = Series(list('abc'), dtype='category')
         result = s.to_frame()
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(result[0],expected)
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(result[0], expected)
         result = s.to_frame(name='foo')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(result['foo'],expected)
+        expected = Series(list('abc'), dtype='category', name='foo')
+        tm.assert_series_equal(result['foo'], expected)
 
         # list-like creation
-        df = DataFrame(list('abc'),dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df[0],expected)
+        df = DataFrame(list('abc'), dtype='category')
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(df[0], expected)
 
         # ndim != 1
         df = DataFrame([pd.Categorical(list('abc'))])
@@ -1833,7 +1834,11 @@ def f(x):
         # Monotonic
         df = DataFrame({"a": [5, 15, 25]})
         c = pd.cut(df.a, bins=[0,10,20,30,40])
-        tm.assert_series_equal(df.a.groupby(c).transform(sum), df['a'])
+
+        result = df.a.groupby(c).transform(sum)
+        tm.assert_series_equal(result, df['a'], check_names=False)
+        self.assertTrue(result.name is None)
+
         tm.assert_series_equal(df.a.groupby(c).transform(lambda xs: np.sum(xs)), df['a'])
         tm.assert_frame_equal(df.groupby(c).transform(sum), df[['a']])
         tm.assert_frame_equal(df.groupby(c).transform(lambda xs: np.max(xs)), df[['a']])
@@ -1845,7 +1850,11 @@ def f(x):
         # Non-monotonic
         df = DataFrame({"a": [5, 15, 25, -5]})
         c = pd.cut(df.a, bins=[-10, 0,10,20,30,40])
-        tm.assert_series_equal(df.a.groupby(c).transform(sum), df['a'])
+
+        result = df.a.groupby(c).transform(sum)
+        tm.assert_series_equal(result, df['a'], check_names=False)
+        self.assertTrue(result.name is None)
+
         tm.assert_series_equal(df.a.groupby(c).transform(lambda xs: np.sum(xs)), df['a'])
         tm.assert_frame_equal(df.groupby(c).transform(sum), df[['a']])
         tm.assert_frame_equal(df.groupby(c).transform(lambda xs: np.sum(xs)), df[['a']])
@@ -1983,19 +1992,19 @@ def test_slicing(self):
         df = DataFrame({'value': (np.arange(100)+1).astype('int64')})
         df['D'] = pd.cut(df.value, bins=[0,25,50,75,100])
 
-        expected = Series([11,'(0, 25]'],index=['value','D'])
+        expected = Series([11,'(0, 25]'], index=['value','D'], name=10)
         result = df.iloc[10]
-        tm.assert_series_equal(result,expected)
+        tm.assert_series_equal(result, expected)
 
         expected = DataFrame({'value': np.arange(11,21).astype('int64')},
                              index=np.arange(10,20).astype('int64'))
         expected['D'] = pd.cut(expected.value, bins=[0,25,50,75,100])
         result = df.iloc[10:20]
-        tm.assert_frame_equal(result,expected)
+        tm.assert_frame_equal(result, expected)
 
-        expected = Series([9,'(0, 25]'],index=['value','D'])
+        expected = Series([9,'(0, 25]'],index=['value', 'D'], name=8)
         result = df.loc[8]
-        tm.assert_series_equal(result,expected)
+        tm.assert_series_equal(result, expected)
 
     def test_slicing_and_getting_ops(self):
 
@@ -2151,7 +2160,8 @@ def test_slicing_doc_examples(self):
         tm.assert_series_equal(result, expected)
 
         result = df.loc["h":"j","cats"]
-        expected = Series(Categorical(['a','b','b'],categories=['a','b','c']),index=['h','i','j'])
+        expected = Series(Categorical(['a','b','b'], name='cats',
+                          categories=['a','b','c']), index=['h','i','j'])
         tm.assert_series_equal(result, expected)
 
         result = df.ix["h":"j",0:1]
@@ -2832,21 +2842,21 @@ def test_to_records(self):
         # GH8626
 
         # dict creation
-        df = DataFrame({ 'A' : list('abc') },dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df['A'],expected)
+        df = DataFrame({ 'A' : list('abc') }, dtype='category')
+        expected = Series(list('abc'), dtype='category', name='A')
+        tm.assert_series_equal(df['A'], expected)
 
         # list-like creation
-        df = DataFrame(list('abc'),dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df[0],expected)
+        df = DataFrame(list('abc'), dtype='category')
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(df[0], expected)
 
         # to record array
         # this coerces
         result = df.to_records()
         expected = np.rec.array([(0, 'a'), (1, 'b'), (2, 'c')],
                                 dtype=[('index', '<i8'), ('0', 'O')])
-        tm.assert_almost_equal(result,expected)
+        tm.assert_almost_equal(result, expected)
 
     def test_numeric_like_ops(self):