MAINT: Rewrite from_csv to read_csv in test_to_csv

Author: gfyoung

pandas/tests/frame/test_to_csv.py

@@ -31,6 +31,12 @@
 
 class TestDataFrameToCSV(TestData):
 
+    def read_csv(self, path, **kwargs):
+        params = dict(index_col=0, parse_dates=True)
+        params.update(**kwargs)
+
+        return pd.read_csv(path, **params)
+
     def test_to_csv_from_csv1(self):
 
         with ensure_clean('__tmp_to_csv_from_csv1__') as path:
@@ -43,36 +49,31 @@ def test_to_csv_from_csv1(self):
 
             # test roundtrip
             self.tsframe.to_csv(path)
+            recons = self.read_csv(path)
+            assert_frame_equal(self.tsframe, recons)
 
             with tm.assert_produces_warning(FutureWarning,
                                             check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-                assert_frame_equal(self.tsframe, recons)
+                depr_recons = DataFrame.from_csv(path)
+                assert_frame_equal(self.tsframe, depr_recons)
 
             self.tsframe.to_csv(path, index_label='index')
+            recons = self.read_csv(path, index_col=None)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path, index_col=None)
-                assert(len(recons.columns) == len(self.tsframe.columns) + 1)
+            assert(len(recons.columns) == len(self.tsframe.columns) + 1)
 
             # no index
             self.tsframe.to_csv(path, index=False)
-
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path, index_col=None)
-                assert_almost_equal(self.tsframe.values, recons.values)
+            recons = self.read_csv(path, index_col=None)
+            assert_almost_equal(self.tsframe.values, recons.values)
 
             # corner case
             dm = DataFrame({'s1': Series(lrange(3), lrange(3)),
                             's2': Series(lrange(2), lrange(2))})
             dm.to_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-                assert_frame_equal(dm, recons)
+            recons = self.read_csv(path)
+            assert_frame_equal(dm, recons)
 
     def test_to_csv_from_csv2(self):
 
@@ -82,36 +83,27 @@ def test_to_csv_from_csv2(self):
             df = DataFrame(np.random.randn(3, 3), index=['a', 'a', 'b'],
                            columns=['x', 'y', 'z'])
             df.to_csv(path)
-
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                result = DataFrame.from_csv(path)
-                assert_frame_equal(result, df)
+            result = self.read_csv(path)
+            assert_frame_equal(result, df)
 
             midx = MultiIndex.from_tuples(
                 [('A', 1, 2), ('A', 1, 2), ('B', 1, 2)])
             df = DataFrame(np.random.randn(3, 3), index=midx,
                            columns=['x', 'y', 'z'])
-            df.to_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                result = DataFrame.from_csv(path, index_col=[0, 1, 2],
-                                            parse_dates=False)
-            # TODO from_csv names index ['Unnamed: 1', 'Unnamed: 2'] should it
-            # ?
+            df.to_csv(path)
+            result = self.read_csv(path, index_col=[0, 1, 2],
+                                   parse_dates=False)
             assert_frame_equal(result, df, check_names=False)
 
             # column aliases
             col_aliases = Index(['AA', 'X', 'Y', 'Z'])
             self.frame2.to_csv(path, header=col_aliases)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                rs = DataFrame.from_csv(path)
-                xp = self.frame2.copy()
-                xp.columns = col_aliases
-                assert_frame_equal(xp, rs)
+            rs = self.read_csv(path)
+            xp = self.frame2.copy()
+            xp.columns = col_aliases
+            assert_frame_equal(xp, rs)
 
             pytest.raises(ValueError, self.frame2.to_csv, path,
                           header=['AA', 'X'])
@@ -251,12 +243,10 @@ def make_dtnat_arr(n, nnat=None):
             df = DataFrame(dict(a=s1, b=s2))
             df.to_csv(pth, chunksize=chunksize)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(pth)._convert(datetime=True,
-                                                          coerce=True)
-                assert_frame_equal(df, recons, check_names=False,
-                                   check_less_precise=True)
+            recons = self.read_csv(pth)._convert(datetime=True,
+                                                 coerce=True)
+            assert_frame_equal(df, recons, check_names=False,
+                               check_less_precise=True)
 
     @pytest.mark.slow
     def test_to_csv_moar(self):
@@ -269,22 +259,17 @@ def _do_test(df, r_dtype=None, c_dtype=None,
                 if rnlvl is not None:
                     kwargs['index_col'] = lrange(rnlvl)
                 kwargs['header'] = lrange(cnlvl)
+
                 with ensure_clean('__tmp_to_csv_moar__') as path:
                     df.to_csv(path, encoding='utf8',
                               chunksize=chunksize, tupleize_cols=False)
-
-                    with tm.assert_produces_warning(FutureWarning,
-                                                    check_stacklevel=False):
-                        recons = DataFrame.from_csv(
-                            path, tupleize_cols=False, **kwargs)
+                    recons = self.read_csv(path, tupleize_cols=False, **kwargs)
             else:
                 kwargs['header'] = 0
+
                 with ensure_clean('__tmp_to_csv_moar__') as path:
                     df.to_csv(path, encoding='utf8', chunksize=chunksize)
-
-                    with tm.assert_produces_warning(FutureWarning,
-                                                    check_stacklevel=False):
-                        recons = DataFrame.from_csv(path, **kwargs)
+                    recons = self.read_csv(path, **kwargs)
 
             def _to_uni(x):
                 if not isinstance(x, compat.text_type):
@@ -426,15 +411,12 @@ def test_to_csv_from_csv_w_some_infs(self):
 
         with ensure_clean() as path:
             self.frame.to_csv(path)
+            recons = self.read_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-
-                # TODO to_csv drops column name
-                assert_frame_equal(self.frame, recons, check_names=False)
-                assert_frame_equal(np.isinf(self.frame),
-                                   np.isinf(recons), check_names=False)
+            # TODO to_csv drops column name
+            assert_frame_equal(self.frame, recons, check_names=False)
+            assert_frame_equal(np.isinf(self.frame),
+                               np.isinf(recons), check_names=False)
 
     def test_to_csv_from_csv_w_all_infs(self):
 
@@ -444,15 +426,12 @@ def test_to_csv_from_csv_w_all_infs(self):
 
         with ensure_clean() as path:
             self.frame.to_csv(path)
+            recons = self.read_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-
-                # TODO to_csv drops column name
-                assert_frame_equal(self.frame, recons, check_names=False)
-                assert_frame_equal(np.isinf(self.frame),
-                                   np.isinf(recons), check_names=False)
+            # TODO to_csv drops column name
+            assert_frame_equal(self.frame, recons, check_names=False)
+            assert_frame_equal(np.isinf(self.frame),
+                               np.isinf(recons), check_names=False)
 
     def test_to_csv_no_index(self):
         # GH 3624, after appending columns, to_csv fails
@@ -482,19 +461,15 @@ def test_to_csv_headers(self):
         to_df = DataFrame([[1, 2], [3, 4]], columns=['X', 'Y'])
         with ensure_clean('__tmp_to_csv_headers__') as path:
             from_df.to_csv(path, header=['X', 'Y'])
+            recons = self.read_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-                assert_frame_equal(to_df, recons)
+            assert_frame_equal(to_df, recons)
 
             from_df.to_csv(path, index=False, header=['X', 'Y'])
+            recons = self.read_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-                recons.reset_index(inplace=True)
-                assert_frame_equal(to_df, recons)
+            recons.reset_index(inplace=True)
+            assert_frame_equal(to_df, recons)
 
     def test_to_csv_multiindex(self):
 
@@ -512,16 +487,14 @@ def test_to_csv_multiindex(self):
             # round trip
             frame.to_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                df = DataFrame.from_csv(path, index_col=[0, 1],
-                                        parse_dates=False)
+            df = self.read_csv(path, index_col=[0, 1],
+                               parse_dates=False)
 
-                # TODO to_csv drops column name
-                assert_frame_equal(frame, df, check_names=False)
-                assert frame.index.names == df.index.names
+            # TODO to_csv drops column name
+            assert_frame_equal(frame, df, check_names=False)
+            assert frame.index.names == df.index.names
 
-            # needed if setUP becomes a classmethod
+            # needed if setUp becomes a class method
             self.frame.index = old_index
 
             # try multiindex with dates
@@ -531,30 +504,22 @@ def test_to_csv_multiindex(self):
             tsframe.index = MultiIndex.from_arrays(new_index)
 
             tsframe.to_csv(path, index_label=['time', 'foo'])
+            recons = self.read_csv(path, index_col=[0, 1])
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path, index_col=[0, 1])
-                # TODO to_csv drops column name
-                assert_frame_equal(tsframe, recons, check_names=False)
+            # TODO to_csv drops column name
+            assert_frame_equal(tsframe, recons, check_names=False)
 
             # do not load index
             tsframe.to_csv(path)
-
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path, index_col=None)
-                assert len(recons.columns) == len(tsframe.columns) + 2
+            recons = self.read_csv(path, index_col=None)
+            assert len(recons.columns) == len(tsframe.columns) + 2
 
             # no index
             tsframe.to_csv(path, index=False)
+            recons = self.read_csv(path, index_col=None)
+            assert_almost_equal(recons.values, self.tsframe.values)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path, index_col=None)
-                assert_almost_equal(recons.values, self.tsframe.values)
-
-            # needed if setUP becomes classmethod
+            # needed if setUp becomes class method
             self.tsframe.index = old_index
 
         with ensure_clean('__tmp_to_csv_multiindex__') as path:
@@ -652,15 +617,13 @@ def _make_frame(names=None):
         with ensure_clean('__tmp_to_csv_multiindex__') as path:
             # empty
             tsframe[:0].to_csv(path)
+            recons = self.read_csv(path)
 
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                recons = DataFrame.from_csv(path)
-                exp = tsframe[:0]
-                exp.index = []
+            exp = tsframe[:0]
+            exp.index = []
 
-                tm.assert_index_equal(recons.columns, exp.columns)
-                assert len(recons) == 0
+            tm.assert_index_equal(recons.columns, exp.columns)
+            assert len(recons) == 0
 
     def test_to_csv_float32_nanrep(self):
         df = DataFrame(np.random.randn(1, 4).astype(np.float32))
@@ -680,11 +643,8 @@ def test_to_csv_withcommas(self):
 
         with ensure_clean('__tmp_to_csv_withcommas__.csv') as path:
             df.to_csv(path)
-
-            with tm.assert_produces_warning(FutureWarning,
-                                            check_stacklevel=False):
-                df2 = DataFrame.from_csv(path)
-                assert_frame_equal(df2, df)
+            df2 = self.read_csv(path)
+            assert_frame_equal(df2, df)
 
     def test_to_csv_mixed(self):
 
@@ -798,11 +758,8 @@ def test_to_csv_wide_frame_formatting(self):
 
     def test_to_csv_bug(self):
         f1 = StringIO('a,1.0\nb,2.0')
-
-        with tm.assert_produces_warning(FutureWarning,
-                                        check_stacklevel=False):
-            df = DataFrame.from_csv(f1, header=None)
-            newdf = DataFrame({'t': df[df.columns[0]]})
+        df = self.read_csv(f1, header=None)
+        newdf = DataFrame({'t': df[df.columns[0]]})
 
         with ensure_clean() as path:
             newdf.to_csv(path)