create compression_no_zip fixture

Author: reidy-p

pandas/conftest.py

@@ -83,3 +83,13 @@ def compression(request):
     Fixture for trying common compression types in compression tests
     """
     return request.param
+
+
+@pytest.fixture(params=[None, 'gzip', 'bz2',
+                        pytest.param('xz', marks=td.skip_if_no_lzma)])
+def compression_no_zip(request):
+    """
+    Fixture for trying common compression types in compression tests
+    except zip
+    """
+    return request.param

pandas/tests/frame/test_to_csv.py

@@ -919,29 +919,29 @@ def test_to_csv_path_is_none(self):
         recons = pd.read_csv(StringIO(csv_str), index_col=0)
         assert_frame_equal(self.frame, recons)
 
-    def test_to_csv_compression(self, compression):
+    def test_to_csv_compression(self, compression_no_zip):
 
         df = DataFrame([[0.123456, 0.234567, 0.567567],
                         [12.32112, 123123.2, 321321.2]],
                        index=['A', 'B'], columns=['X', 'Y', 'Z'])
 
-        if compression != "zip":
-            with ensure_clean() as filename:
+        with ensure_clean() as filename:
 
-                df.to_csv(filename, compression=compression)
+            df.to_csv(filename, compression=compression_no_zip)
 
-                # test the round trip - to_csv -> read_csv
-                rs = read_csv(filename, compression=compression, index_col=0)
-                assert_frame_equal(df, rs)
+            # test the round trip - to_csv -> read_csv
+            rs = read_csv(filename, compression=compression_no_zip,
+                          index_col=0)
+            assert_frame_equal(df, rs)
 
-                # explicitly make sure file is compressed
-                with tm.decompress_file(filename, compression) as fh:
-                    text = fh.read().decode('utf8')
-                    for col in df.columns:
-                        assert col in text
+            # explicitly make sure file is compressed
+            with tm.decompress_file(filename, compression_no_zip) as fh:
+                text = fh.read().decode('utf8')
+                for col in df.columns:
+                    assert col in text
 
-                with tm.decompress_file(filename, compression) as fh:
-                    assert_frame_equal(df, read_csv(fh, index_col=0))
+            with tm.decompress_file(filename, compression_no_zip) as fh:
+                assert_frame_equal(df, read_csv(fh, index_col=0))
 
     def test_to_csv_compression_value_error(self):
         # GH7615

pandas/tests/io/json/test_compression.py

@@ -5,20 +5,20 @@
 from pandas.util.testing import assert_frame_equal, assert_raises_regex
 
 
-def test_compression_roundtrip(compression):
+def test_compression_roundtrip(compression_no_zip):
     df = pd.DataFrame([[0.123456, 0.234567, 0.567567],
                        [12.32112, 123123.2, 321321.2]],
                       index=['A', 'B'], columns=['X', 'Y', 'Z'])
 
-    if compression != 'zip':
-        with tm.ensure_clean() as path:
-            df.to_json(path, compression=compression)
-            assert_frame_equal(df, pd.read_json(path, compression=compression))
+    with tm.ensure_clean() as path:
+        df.to_json(path, compression=compression_no_zip)
+        assert_frame_equal(df, pd.read_json(path,
+                                            compression=compression_no_zip))
 
-            # explicitly ensure file was compressed.
-            with tm.decompress_file(path, compression) as fh:
-                result = fh.read().decode('utf8')
-            assert_frame_equal(df, pd.read_json(result))
+        # explicitly ensure file was compressed.
+        with tm.decompress_file(path, compression_no_zip) as fh:
+            result = fh.read().decode('utf8')
+        assert_frame_equal(df, pd.read_json(result))
 
 
 def test_compress_zip_value_error():
@@ -41,7 +41,7 @@ def test_read_zipped_json():
     assert_frame_equal(uncompressed_df, compressed_df)
 
 
-def test_with_s3_url(compression):
+def test_with_s3_url(compression_no_zip):
     boto3 = pytest.importorskip('boto3')
     pytest.importorskip('s3fs')
     moto = pytest.importorskip('moto')
@@ -52,39 +52,37 @@ def test_with_s3_url(compression):
         bucket = conn.create_bucket(Bucket="pandas-test")
 
         with tm.ensure_clean() as path:
-            df.to_json(path, compression=compression)
+            df.to_json(path, compression=compression_no_zip)
             with open(path, 'rb') as f:
                 bucket.put_object(Key='test-1', Body=f)
 
         roundtripped_df = pd.read_json('s3://pandas-test/test-1',
-                                       compression=compression)
+                                       compression=compression_no_zip)
         assert_frame_equal(df, roundtripped_df)
 
 
-def test_lines_with_compression(compression):
+def test_lines_with_compression(compression_no_zip):
 
-    if compression != 'zip':
-        with tm.ensure_clean() as path:
-            df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
-            df.to_json(path, orient='records', lines=True,
-                       compression=compression)
-            roundtripped_df = pd.read_json(path, lines=True,
-                                           compression=compression)
-            assert_frame_equal(df, roundtripped_df)
+    with tm.ensure_clean() as path:
+        df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
+        df.to_json(path, orient='records', lines=True,
+                   compression=compression_no_zip)
+        roundtripped_df = pd.read_json(path, lines=True,
+                                       compression=compression_no_zip)
+        assert_frame_equal(df, roundtripped_df)
 
 
-def test_chunksize_with_compression(compression):
+def test_chunksize_with_compression(compression_no_zip):
 
-    if compression != 'zip':
-        with tm.ensure_clean() as path:
-            df = pd.read_json('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}')
-            df.to_json(path, orient='records', lines=True,
-                       compression=compression)
-
-            roundtripped_df = pd.concat(pd.read_json(path, lines=True,
-                                                     chunksize=1,
-                                                     compression=compression))
-            assert_frame_equal(df, roundtripped_df)
+    with tm.ensure_clean() as path:
+        df = pd.read_json('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}')
+        df.to_json(path, orient='records', lines=True,
+                   compression=compression_no_zip)
+
+        res = pd.read_json(path, lines=True, chunksize=1,
+                           compression=compression_no_zip)
+        roundtripped_df = pd.concat(res)
+        assert_frame_equal(df, roundtripped_df)
 
 
 def test_write_unsupported_compression_type():

pandas/tests/io/test_pickle.py

@@ -352,27 +352,26 @@ def compress_file(self, src_path, dest_path, compression):
                 f.write(fh.read())
             f.close()
 
-    def test_write_explicit(self, compression, get_random_path):
+    def test_write_explicit(self, compression_no_zip, get_random_path):
         base = get_random_path
         path1 = base + ".compressed"
         path2 = base + ".raw"
 
-        if compression != "zip":
-            with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
-                df = tm.makeDataFrame()
+        with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
+            df = tm.makeDataFrame()
 
-                # write to compressed file
-                df.to_pickle(p1, compression=compression)
+            # write to compressed file
+            df.to_pickle(p1, compression=compression_no_zip)
 
-                # decompress
-                with tm.decompress_file(p1, compression=compression) as f:
-                    with open(p2, "wb") as fh:
-                        fh.write(f.read())
+            # decompress
+            with tm.decompress_file(p1, compression=compression_no_zip) as f:
+                with open(p2, "wb") as fh:
+                    fh.write(f.read())
 
-                # read decompressed file
-                df2 = pd.read_pickle(p2, compression=None)
+            # read decompressed file
+            df2 = pd.read_pickle(p2, compression=None)
 
-                tm.assert_frame_equal(df, df2)
+            tm.assert_frame_equal(df, df2)
 
     @pytest.mark.parametrize('compression', ['', 'None', 'bad', '7z'])
     def test_write_explicit_bad(self, compression, get_random_path):

pandas/tests/series/test_io.py

@@ -138,30 +138,29 @@ def test_to_csv_path_is_none(self):
         csv_str = s.to_csv(path=None)
         assert isinstance(csv_str, str)
 
-    def test_to_csv_compression(self, compression):
+    def test_to_csv_compression(self, compression_no_zip):
 
         s = Series([0.123456, 0.234567, 0.567567], index=['A', 'B', 'C'],
                    name='X')
 
-        if compression != 'zip':
-            with ensure_clean() as filename:
+        with ensure_clean() as filename:
 
-                s.to_csv(filename, compression=compression, header=True)
+            s.to_csv(filename, compression=compression_no_zip, header=True)
 
-                # test the round trip - to_csv -> read_csv
-                rs = pd.read_csv(filename, compression=compression,
-                                 index_col=0, squeeze=True)
-                assert_series_equal(s, rs)
+            # test the round trip - to_csv -> read_csv
+            rs = pd.read_csv(filename, compression=compression_no_zip,
+                             index_col=0, squeeze=True)
+            assert_series_equal(s, rs)
 
-                # explicitly ensure file was compressed
-                with tm.decompress_file(filename, compression) as fh:
-                    text = fh.read().decode('utf8')
-                    assert s.name in text
+            # explicitly ensure file was compressed
+            with tm.decompress_file(filename, compression_no_zip) as fh:
+                text = fh.read().decode('utf8')
+                assert s.name in text
 
-                with tm.decompress_file(filename, compression) as fh:
-                    assert_series_equal(s, pd.read_csv(fh,
-                                                       index_col=0,
-                                                       squeeze=True))
+            with tm.decompress_file(filename, compression_no_zip) as fh:
+                assert_series_equal(s, pd.read_csv(fh,
+                                                   index_col=0,
+                                                   squeeze=True))
 
 
 class TestSeriesIO(TestData):