def __init__(self, filename, mode="r", buffering=None, compresslevel=9): """Open a bzip2-compressed file. If filename is a str or bytes object, is gives the name of the file to be opened. Otherwise, it should be a file object, which will be used to read or write the compressed data. mode can be 'r' for reading (default), 'w' for (over)writing, or 'a' for appending. These can equivalently be given as 'rb', 'wb', and 'ab'. buffering is ignored. Its use is deprecated. If mode is 'w' or 'a', compresslevel can be a number between 1 and 9 specifying the level of compression: 1 produces the least compression, and 9 (default) produces the most compression. If mode is 'r', the input file may be the concatenation of multiple compressed streams. """ # This lock must be recursive, so that BufferedIOBase's # readline(), readlines() and writelines() don't deadlock. self._lock = RLock() self._fp = None self._closefp = False self._mode = _MODE_CLOSED self._pos = 0 self._size = -1 if buffering is not None: warnings.warn("Use of 'buffering' argument is deprecated", DeprecationWarning) if not (1 <= compresslevel <= 9): raise ValueError("compresslevel must be between 1 and 9") if mode in ("", "r", "rb"): mode = "rb" mode_code = _MODE_READ self._decompressor = BZ2Decompressor() self._buffer = None elif mode in ("w", "wb"): mode = "wb" mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) elif mode in ("a", "ab"): mode = "ab" mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) else: raise ValueError("Invalid mode: {!r}".format(mode)) if isinstance(filename, (str, bytes)): self._fp = builtins.open(filename, mode) self._closefp = True self._mode = mode_code elif hasattr(filename, "read") or hasattr(filename, "write"): self._fp = filename self._mode = mode_code else: raise TypeError("filename must be a str or bytes object, or a file")
def __init__(self, filename, mode="r", *, compresslevel=9): """Open a bzip2-compressed file. If filename is a str, bytes, or PathLike object, it gives the name of the file to be opened. Otherwise, it should be a file object, which will be used to read or write the compressed data. mode can be 'r' for reading (default), 'w' for (over)writing, 'x' for creating exclusively, or 'a' for appending. These can equivalently be given as 'rb', 'wb', 'xb', and 'ab'. If mode is 'w', 'x' or 'a', compresslevel can be a number between 1 and 9 specifying the level of compression: 1 produces the least compression, and 9 (default) produces the most compression. If mode is 'r', the input file may be the concatenation of multiple compressed streams. """ self._fp = None self._closefp = False self._mode = _MODE_CLOSED if not (1 <= compresslevel <= 9): raise ValueError("compresslevel must be between 1 and 9") if mode in ("", "r", "rb"): mode = "rb" mode_code = _MODE_READ elif mode in ("w", "wb"): mode = "wb" mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) elif mode in ("x", "xb"): mode = "xb" mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) elif mode in ("a", "ab"): mode = "ab" mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) else: raise ValueError("Invalid mode: %r" % (mode,)) if isinstance(filename, (str, bytes, os.PathLike)): self._fp = _builtin_open(filename, mode) self._closefp = True self._mode = mode_code elif hasattr(filename, "read") or hasattr(filename, "write"): self._fp = filename self._mode = mode_code else: raise TypeError("filename must be a str, bytes, file or PathLike object") if self._mode == _MODE_READ: raw = _compression.DecompressReader(self._fp, BZ2Decompressor, trailing_error=OSError) self._buffer = io.BufferedReader(raw) else: self._pos = 0
def test_creation(self): from _bz2 import BZ2Compressor raises(TypeError, BZ2Compressor, "foo") raises(ValueError, BZ2Compressor, 10) BZ2Compressor(1) BZ2Compressor(9)
def test_compressor_pickle_error(self): from _bz2 import BZ2Compressor import pickle exc = raises(TypeError, pickle.dumps, BZ2Compressor()) assert exc.value.args[ 0] == "cannot serialize '_bz2.BZ2Compressor' object"
def test_compress(self): from _bz2 import BZ2Compressor bz2c = BZ2Compressor() raises(TypeError, bz2c.compress) data = bz2c.compress(self.TEXT) data += bz2c.flush() assert self.decompress(data) == self.TEXT
def compress(data, compresslevel=9): """Compress a block of data. compresslevel, if given, must be a number between 1 and 9. For incremental compression, use a BZ2Compressor object instead. """ comp = BZ2Compressor(compresslevel) return comp.compress(data) + comp.flush()
def test_compress_huge_data(self): if not self.HUGE_OK: skip("skipping test requiring lots of memory") from _bz2 import BZ2Compressor HUGE_DATA = self.TEXT * 10000 bz2c = BZ2Compressor() raises(TypeError, bz2c.compress) data = bz2c.compress(HUGE_DATA) data += bz2c.flush() assert self.decompress(data) == HUGE_DATA
def test_compress_chunks_10(self): from _bz2 import BZ2Compressor bz2c = BZ2Compressor() n = 0 data = b"" while True: temp = self.TEXT[n * 10:(n + 1) * 10] if not temp: break data += bz2c.compress(temp) n += 1 data += bz2c.flush() assert self.decompress(data) == self.TEXT
def test_buffer(self): from _bz2 import BZ2Compressor bz2c = BZ2Compressor() data = bz2c.compress(memoryview(self.TEXT)) data += bz2c.flush() assert self.decompress(data) == self.TEXT
def __init__(self, filename, mode='r', buffering=None, compresslevel=9): """Open a bzip2-compressed file. If filename is a str, bytes, or PathLike object, it gives the name of the file to be opened. Otherwise, it should be a file object, which will be used to read or write the compressed data. mode can be 'r' for reading (default), 'w' for (over)writing, 'x' for creating exclusively, or 'a' for appending. These can equivalently be given as 'rb', 'wb', 'xb', and 'ab'. buffering is ignored. Its use is deprecated. If mode is 'w', 'x' or 'a', compresslevel can be a number between 1 and 9 specifying the level of compression: 1 produces the least compression, and 9 (default) produces the most compression. If mode is 'r', the input file may be the concatenation of multiple compressed streams. """ self._lock = RLock() self._fp = None self._closefp = False self._mode = _MODE_CLOSED if buffering is not None: warnings.warn("Use of 'buffering' argument is deprecated", DeprecationWarning) if not 1 <= compresslevel <= 9: raise ValueError('compresslevel must be between 1 and 9') if mode in ('', 'r', 'rb'): mode = 'rb' mode_code = _MODE_READ elif mode in ('w', 'wb'): mode = 'wb' mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) elif mode in ('x', 'xb'): mode = 'xb' mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) elif mode in ('a', 'ab'): mode = 'ab' mode_code = _MODE_WRITE self._compressor = BZ2Compressor(compresslevel) else: raise ValueError('Invalid mode: %r' % (mode, )) if isinstance(filename, (str, bytes, os.PathLike)): self._fp = _builtin_open(filename, mode) self._closefp = True self._mode = mode_code elif hasattr(filename, 'read') or hasattr(filename, 'write'): self._fp = filename self._mode = mode_code else: raise TypeError( 'filename must be a str, bytes, file or PathLike object') if self._mode == _MODE_READ: raw = _compression.DecompressReader((self._fp), BZ2Decompressor, trailing_error=OSError) self._buffer = io.BufferedReader(raw) else: self._pos = 0