Rename C/DParameter to (De)CompressionParameter

Author: emmatyping

Lib/compression/zstd/__init__.py

@@ -4,9 +4,9 @@
     # compression.zstd
     "COMPRESSION_LEVEL_DEFAULT",
     "compress",
-    "CParameter",
+    "CompressionParameter",
     "decompress",
-    "DParameter",
+    "DecompressionParameter",
     "finalize_dict",
     "get_frame_info",
     "Strategy",
@@ -146,7 +146,7 @@ def compress(data, level=None, options=None, zstd_dict=None):
     COMPRESSION_LEVEL_DEFAULT
 
     *options* is a dict object that contains advanced compression
-    parameters. See CParameter for more on options.
+    parameters. See CompressionParameter for more on options.
 
     *zstd_dict* is a ZstdDict object, a pre-trained Zstandard dictionary. See
     the function train_dict for how to train a ZstdDict on sample data.
@@ -163,7 +163,7 @@ def decompress(data, zstd_dict=None, options=None):
     the function train_dict for how to train a ZstdDict on sample data.
 
     *options* is a dict object that contains advanced compression
-    parameters. See DParameter for more on options.
+    parameters. See DecompressionParameter for more on options.
 
     For incremental decompression, use a ZstdDecompressor instead.
     """
@@ -180,7 +180,7 @@ def decompress(data, zstd_dict=None, options=None):
     return b"".join(results)
 
 
-class CParameter(enum.IntEnum):
+class CompressionParameter(enum.IntEnum):
     """Compression parameters"""
 
     compression_level = _zstd._ZSTD_c_compressionLevel
@@ -215,7 +215,7 @@ def bounds(self):
         return _zstd._get_param_bounds(is_compress=True, parameter=self.value)
 
 
-class DParameter(enum.IntEnum):
+class DecompressionParameter(enum.IntEnum):
     """Decompression parameters"""
 
     window_log_max = _zstd._ZSTD_d_windowLogMax
@@ -248,5 +248,5 @@ class Strategy(enum.IntEnum):
     btultra2 = _zstd._ZSTD_btultra2
 
 
-# Set CParameter/DParameter types for validity check
-_zstd._set_parameter_types(CParameter, DParameter)
+# Set CompressionParameter/DecompressionParameter types for validity check
+_zstd._set_parameter_types(CompressionParameter, DecompressionParameter)

Lib/compression/zstd/_zstdfile.py

@@ -60,7 +60,8 @@ def __init__(
         COMPRESSION_LEVEL_DEFAULT
 
         options is a dict object that contains advanced compression
-        parameters. See CParameter or DParameter for more on options.
+        parameters. See CompressionParameter or DecompressionParameter for more
+        information on options.
 
         zstd_dict is a ZstdDict object, a pre-trained Zstandard dictionary.
         See the function train_dict for how to train a ZstdDict on sample data.

Lib/test/test_zstd.py

@@ -32,8 +32,8 @@
     get_frame_size,
     finalize_dict,
     train_dict,
-    CParameter,
-    DParameter,
+    CompressionParameter,
+    DecompressionParameter,
     Strategy,
     ZstdFile,
 )
@@ -67,14 +67,14 @@
 
 def setUpModule():
     global SUPPORT_MULTITHREADING
-    SUPPORT_MULTITHREADING = CParameter.nb_workers.bounds() != (0, 0)
+    SUPPORT_MULTITHREADING = CompressionParameter.nb_workers.bounds() != (0, 0)
     # uncompressed size 130KB, more than a zstd block.
     # with a frame epilogue, 4 bytes checksum.
     global DAT_130K_D
     DAT_130K_D = bytes([random.randint(0, 127) for _ in range(130*_1K)])
 
     global DAT_130K_C
-    DAT_130K_C = compress(DAT_130K_D, options={CParameter.checksum_flag:1})
+    DAT_130K_C = compress(DAT_130K_D, options={CompressionParameter.checksum_flag:1})
 
     global DECOMPRESSED_DAT
     DECOMPRESSED_DAT = b'abcdefg123456' * 1000
@@ -132,7 +132,7 @@ def test_version(self):
         self.assertEqual(s, zstd_version)
 
     def test_compressionLevel_values(self):
-        min, max = CParameter.compression_level.bounds()
+        min, max = CompressionParameter.compression_level.bounds()
         self.assertIs(type(COMPRESSION_LEVEL_DEFAULT), int)
         self.assertIs(type(min), int)
         self.assertIs(type(max), int)
@@ -146,7 +146,7 @@ def test_roundtrip_default(self):
 
     def test_roundtrip_level(self):
         raw_dat = THIS_FILE_BYTES[: len(THIS_FILE_BYTES) // 6]
-        level_min, level_max = CParameter.compression_level.bounds()
+        level_min, level_max = CompressionParameter.compression_level.bounds()
 
         for level in range(max(-20, level_min), level_max + 1):
             dat1 = compress(raw_dat, level)
@@ -202,7 +202,7 @@ def test_simple_compress_bad_args(self):
             ZstdCompressor(options={2**31: 100})
 
         with self.assertRaises(ZstdError):
-            ZstdCompressor(options={CParameter.window_log: 100})
+            ZstdCompressor(options={CompressionParameter.window_log: 100})
         with self.assertRaises(ZstdError):
             ZstdCompressor(options={3333: 100})
 
@@ -228,56 +228,56 @@ def test_simple_compress_bad_args(self):
         zc.flush(zc.FLUSH_FRAME)
 
     def test_compress_parameters(self):
-        d = {CParameter.compression_level : 10,
-
-             CParameter.window_log : 12,
-             CParameter.hash_log : 10,
-             CParameter.chain_log : 12,
-             CParameter.search_log : 12,
-             CParameter.min_match : 4,
-             CParameter.target_length : 12,
-             CParameter.strategy : Strategy.lazy,
-
-             CParameter.enable_long_distance_matching : 1,
-             CParameter.ldm_hash_log : 12,
-             CParameter.ldm_min_match : 11,
-             CParameter.ldm_bucket_size_log : 5,
-             CParameter.ldm_hash_rate_log : 12,
-
-             CParameter.content_size_flag : 1,
-             CParameter.checksum_flag : 1,
-             CParameter.dict_id_flag : 0,
-
-             CParameter.nb_workers : 2 if SUPPORT_MULTITHREADING else 0,
-             CParameter.job_size : 5*_1M if SUPPORT_MULTITHREADING else 0,
-             CParameter.overlap_log : 9 if SUPPORT_MULTITHREADING else 0,
+        d = {CompressionParameter.compression_level : 10,
+
+             CompressionParameter.window_log : 12,
+             CompressionParameter.hash_log : 10,
+             CompressionParameter.chain_log : 12,
+             CompressionParameter.search_log : 12,
+             CompressionParameter.min_match : 4,
+             CompressionParameter.target_length : 12,
+             CompressionParameter.strategy : Strategy.lazy,
+
+             CompressionParameter.enable_long_distance_matching : 1,
+             CompressionParameter.ldm_hash_log : 12,
+             CompressionParameter.ldm_min_match : 11,
+             CompressionParameter.ldm_bucket_size_log : 5,
+             CompressionParameter.ldm_hash_rate_log : 12,
+
+             CompressionParameter.content_size_flag : 1,
+             CompressionParameter.checksum_flag : 1,
+             CompressionParameter.dict_id_flag : 0,
+
+             CompressionParameter.nb_workers : 2 if SUPPORT_MULTITHREADING else 0,
+             CompressionParameter.job_size : 5*_1M if SUPPORT_MULTITHREADING else 0,
+             CompressionParameter.overlap_log : 9 if SUPPORT_MULTITHREADING else 0,
              }
         ZstdCompressor(options=d)
 
         # larger than signed int, ValueError
         d1 = d.copy()
-        d1[CParameter.ldm_bucket_size_log] = 2**31
+        d1[CompressionParameter.ldm_bucket_size_log] = 2**31
         self.assertRaises(ValueError, ZstdCompressor, options=d1)
 
         # clamp compressionLevel
-        level_min, level_max = CParameter.compression_level.bounds()
+        level_min, level_max = CompressionParameter.compression_level.bounds()
         compress(b'', level_max+1)
         compress(b'', level_min-1)
 
-        compress(b'', options={CParameter.compression_level:level_max+1})
-        compress(b'', options={CParameter.compression_level:level_min-1})
+        compress(b'', options={CompressionParameter.compression_level:level_max+1})
+        compress(b'', options={CompressionParameter.compression_level:level_min-1})
 
         # zstd lib doesn't support MT compression
         if not SUPPORT_MULTITHREADING:
             with self.assertRaises(ZstdError):
-                ZstdCompressor(options={CParameter.nb_workers:4})
+                ZstdCompressor(options={CompressionParameter.nb_workers:4})
             with self.assertRaises(ZstdError):
-                ZstdCompressor(options={CParameter.job_size:4})
+                ZstdCompressor(options={CompressionParameter.job_size:4})
             with self.assertRaises(ZstdError):
-                ZstdCompressor(options={CParameter.overlap_log:4})
+                ZstdCompressor(options={CompressionParameter.overlap_log:4})
 
         # out of bounds error msg
-        option = {CParameter.window_log:100}
+        option = {CompressionParameter.window_log:100}
         with self.assertRaisesRegex(ZstdError,
                 (r'Error when setting zstd compression parameter "window_log", '
                  r'it should \d+ <= value <= \d+, provided value is 100\. '
@@ -286,7 +286,7 @@ def test_compress_parameters(self):
 
     def test_unknown_compression_parameter(self):
         KEY = 100001234
-        option = {CParameter.compression_level: 10,
+        option = {CompressionParameter.compression_level: 10,
                   KEY: 200000000}
         pattern = r'Zstd compression parameter.*?"unknown parameter \(key %d\)"' \
                   % KEY
@@ -299,8 +299,8 @@ def test_zstd_multithread_compress(self):
         size = 40*_1M
         b = THIS_FILE_BYTES * (size // len(THIS_FILE_BYTES))
 
-        options = {CParameter.compression_level : 4,
-                   CParameter.nb_workers : 2}
+        options = {CompressionParameter.compression_level : 4,
+                   CompressionParameter.nb_workers : 2}
 
         # compress()
         dat1 = compress(b, options=options)
@@ -388,7 +388,7 @@ def test_simple_decompress_bad_args(self):
             ZstdDecompressor(options={2**31 : 100})
 
         with self.assertRaises(ZstdError):
-            ZstdDecompressor(options={DParameter.window_log_max:100})
+            ZstdDecompressor(options={DecompressionParameter.window_log_max:100})
         with self.assertRaises(ZstdError):
             ZstdDecompressor(options={3333 : 100})
 
@@ -400,16 +400,16 @@ def test_simple_decompress_bad_args(self):
         lzd.decompress(empty)
 
     def test_decompress_parameters(self):
-        d = {DParameter.window_log_max : 15}
+        d = {DecompressionParameter.window_log_max : 15}
         ZstdDecompressor(options=d)
 
         # larger than signed int, ValueError
         d1 = d.copy()
-        d1[DParameter.window_log_max] = 2**31
+        d1[DecompressionParameter.window_log_max] = 2**31
         self.assertRaises(ValueError, ZstdDecompressor, None, d1)
 
         # out of bounds error msg
-        options = {DParameter.window_log_max:100}
+        options = {DecompressionParameter.window_log_max:100}
         with self.assertRaisesRegex(ZstdError,
                 (r'Error when setting zstd decompression parameter "window_log_max", '
                  r'it should \d+ <= value <= \d+, provided value is 100\. '
@@ -418,7 +418,7 @@ def test_decompress_parameters(self):
 
     def test_unknown_decompression_parameter(self):
         KEY = 100001234
-        options = {DParameter.window_log_max: DParameter.window_log_max.bounds()[1],
+        options = {DecompressionParameter.window_log_max: DecompressionParameter.window_log_max.bounds()[1],
                   KEY: 200000000}
         pattern = r'Zstd decompression parameter.*?"unknown parameter \(key %d\)"' \
                   % KEY
@@ -517,7 +517,7 @@ def test_decompressor_arg(self):
 
         ZstdDecompressor()
         ZstdDecompressor(zd, {})
-        ZstdDecompressor(zstd_dict=zd, options={DParameter.window_log_max:25})
+        ZstdDecompressor(zstd_dict=zd, options={DecompressionParameter.window_log_max:25})
 
     def test_decompressor_1(self):
         # empty
@@ -662,7 +662,7 @@ class DecompressorFlagsTestCase(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        options = {CParameter.checksum_flag:1}
+        options = {CompressionParameter.checksum_flag:1}
         c = ZstdCompressor(options=options)
 
         cls.DECOMPRESSED_42 = b'a'*42
@@ -1294,9 +1294,9 @@ def test_as_digested_dict(self):
             zd.as_undigested_dict = b'1234'
 
     def test_advanced_compression_parameters(self):
-        options = {CParameter.compression_level: 6,
-                  CParameter.window_log: 20,
-                  CParameter.enable_long_distance_matching: 1}
+        options = {CompressionParameter.compression_level: 6,
+                  CompressionParameter.window_log: 20,
+                  CompressionParameter.enable_long_distance_matching: 1}
 
         # automatically select
         dat = compress(SAMPLES[0], options=options, zstd_dict=TRAINED_DICT)
@@ -1327,14 +1327,14 @@ def test_init(self):
 
         with ZstdFile(io.BytesIO(), "w", level=12) as f:
             pass
-        with ZstdFile(io.BytesIO(), "w", options={CParameter.checksum_flag:1}) as f:
+        with ZstdFile(io.BytesIO(), "w", options={CompressionParameter.checksum_flag:1}) as f:
             pass
         with ZstdFile(io.BytesIO(), "w", options={}) as f:
             pass
         with ZstdFile(io.BytesIO(), "w", level=20, zstd_dict=TRAINED_DICT) as f:
             pass
 
-        with ZstdFile(io.BytesIO(), "r", options={DParameter.window_log_max:25}) as f:
+        with ZstdFile(io.BytesIO(), "r", options={DecompressionParameter.window_log_max:25}) as f:
             pass
         with ZstdFile(io.BytesIO(), "r", options={}, zstd_dict=TRAINED_DICT) as f:
             pass
@@ -1420,10 +1420,13 @@ def test_init_bad_mode(self):
         with self.assertRaises(ValueError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rw")
 
-        with self.assertRaisesRegex(TypeError, r"NOT be CParameter"):
-            ZstdFile(io.BytesIO(), 'rb', options={CParameter.compression_level:5})
-        with self.assertRaisesRegex(TypeError, r"NOT be DParameter"):
-            ZstdFile(io.BytesIO(), 'wb', options={DParameter.window_log_max:21})
+        with self.assertRaisesRegex(TypeError, r"NOT be CompressionParameter"):
+            ZstdFile(io.BytesIO(), 'rb', 
+                     options={CompressionParameter.compression_level:5})
+        with self.assertRaisesRegex(TypeError,
+                                    r"NOT be DecompressionParameter"):
+            ZstdFile(io.BytesIO(), 'wb', 
+                     options={DecompressionParameter.window_log_max:21})
 
         with self.assertRaises(TypeError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r", level=12)
@@ -1435,14 +1438,14 @@ def test_init_bad_check(self):
         with self.assertRaises(ZstdError):
             ZstdFile(io.BytesIO(), "w", options={999:9999})
         with self.assertRaises(ZstdError):
-            ZstdFile(io.BytesIO(), "w", options={CParameter.window_log:99})
+            ZstdFile(io.BytesIO(), "w", options={CompressionParameter.window_log:99})
 
         with self.assertRaises(TypeError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r", options=33)
 
         with self.assertRaises(ValueError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
-                             options={DParameter.window_log_max:2**31})
+                             options={DecompressionParameter.window_log_max:2**31})
 
         with self.assertRaises(ZstdError):
             ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
@@ -1639,7 +1642,7 @@ def test_read_0(self):
             self.assertEqual(f.read(0), b"")
             self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
         with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
-                              options={DParameter.window_log_max:20}) as f:
+                              options={DecompressionParameter.window_log_max:20}) as f:
             self.assertEqual(f.read(0), b"")
 
         # empty file
@@ -1854,16 +1857,16 @@ def test_write(self):
             self.assertEqual(dst.getvalue(), expected)
 
         with io.BytesIO() as dst:
-            with ZstdFile(dst, "w", options={CParameter.checksum_flag:1}) as f:
+            with ZstdFile(dst, "w", options={CompressionParameter.checksum_flag:1}) as f:
                 f.write(raw_data)
 
-            comp = ZstdCompressor(options={CParameter.checksum_flag:1})
+            comp = ZstdCompressor(options={CompressionParameter.checksum_flag:1})
             expected = comp.compress(raw_data) + comp.flush()
             self.assertEqual(dst.getvalue(), expected)
 
         with io.BytesIO() as dst:
-            options = {CParameter.compression_level:-5,
-                      CParameter.checksum_flag:1}
+            options = {CompressionParameter.compression_level:-5,
+                      CompressionParameter.checksum_flag:1}
             with ZstdFile(dst, "w",
                           options=options) as f:
                 f.write(raw_data)
@@ -2321,11 +2324,11 @@ def test_bad_params(self):
         os.remove(TESTFN)
 
     def test_option(self):
-        options = {DParameter.window_log_max:25}
+        options = {DecompressionParameter.window_log_max:25}
         with open(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rb", options=options) as f:
             self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
 
-        options = {CParameter.compression_level:12}
+        options = {CompressionParameter.compression_level:12}
         with io.BytesIO() as bio:
             with open(bio, "wb", options=options) as f:
                 f.write(DECOMPRESSED_100_PLUS_32KB)