Mercurial: comparison contrib/python-zstandard/zstandard/cffi.py

equal deleted inserted replaced

-:668eff08387f
+:675775c33ab6
+# Copyright (c) 2016-present, Gregory Szorc
+# All rights reserved.
+#
+# This software may be modified and distributed under the terms
+# of the BSD license. See the LICENSE file for details.
+"""Python interface to the Zstandard (zstd) compression library."""
+from __future__ import absolute_import, unicode_literals
+# This should match what the C extension exports.
+__all__ = [
+#'BufferSegment',
+#'BufferSegments',
+#'BufferWithSegments',
+#'BufferWithSegmentsCollection',
+'CompressionParameters',
+'ZstdCompressionDict',
+'ZstdCompressionParameters',
+'ZstdCompressor',
+'ZstdError',
+'ZstdDecompressor',
+'FrameParameters',
+'estimate_decompression_context_size',
+'frame_content_size',
+'frame_header_size',
+'get_frame_parameters',
+'train_dictionary',
+# Constants.
+'FLUSH_BLOCK',
+'FLUSH_FRAME',
+'COMPRESSOBJ_FLUSH_FINISH',
+'COMPRESSOBJ_FLUSH_BLOCK',
+'ZSTD_VERSION',
+'FRAME_HEADER',
+'CONTENTSIZE_UNKNOWN',
+'CONTENTSIZE_ERROR',
+'MAX_COMPRESSION_LEVEL',
+'COMPRESSION_RECOMMENDED_INPUT_SIZE',
+'COMPRESSION_RECOMMENDED_OUTPUT_SIZE',
+'DECOMPRESSION_RECOMMENDED_INPUT_SIZE',
+'DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE',
+'MAGIC_NUMBER',
+'BLOCKSIZELOG_MAX',
+'BLOCKSIZE_MAX',
+'WINDOWLOG_MIN',
+'WINDOWLOG_MAX',
+'CHAINLOG_MIN',
+'CHAINLOG_MAX',
+'HASHLOG_MIN',
+'HASHLOG_MAX',
+'HASHLOG3_MAX',
+'MINMATCH_MIN',
+'MINMATCH_MAX',
+'SEARCHLOG_MIN',
+'SEARCHLOG_MAX',
+'SEARCHLENGTH_MIN',
+'SEARCHLENGTH_MAX',
+'TARGETLENGTH_MIN',
+'TARGETLENGTH_MAX',
+'LDM_MINMATCH_MIN',
+'LDM_MINMATCH_MAX',
+'LDM_BUCKETSIZELOG_MAX',
+'STRATEGY_FAST',
+'STRATEGY_DFAST',
+'STRATEGY_GREEDY',
+'STRATEGY_LAZY',
+'STRATEGY_LAZY2',
+'STRATEGY_BTLAZY2',
+'STRATEGY_BTOPT',
+'STRATEGY_BTULTRA',
+'STRATEGY_BTULTRA2',
+'DICT_TYPE_AUTO',
+'DICT_TYPE_RAWCONTENT',
+'DICT_TYPE_FULLDICT',
+'FORMAT_ZSTD1',
+'FORMAT_ZSTD1_MAGICLESS',
+]
+import io
+import os
+import sys
+from _zstd_cffi import (
+ffi,
+lib,
+)
+if sys.version_info[0] == 2:
+bytes_type = str
+int_type = long
+else:
+bytes_type = bytes
+int_type = int
+COMPRESSION_RECOMMENDED_INPUT_SIZE = lib.ZSTD_CStreamInSize()
+COMPRESSION_RECOMMENDED_OUTPUT_SIZE = lib.ZSTD_CStreamOutSize()
+DECOMPRESSION_RECOMMENDED_INPUT_SIZE = lib.ZSTD_DStreamInSize()
+DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE = lib.ZSTD_DStreamOutSize()
+new_nonzero = ffi.new_allocator(should_clear_after_alloc=False)
+MAX_COMPRESSION_LEVEL = lib.ZSTD_maxCLevel()
+MAGIC_NUMBER = lib.ZSTD_MAGICNUMBER
+FRAME_HEADER = b'\x28\xb5\x2f\xfd'
+CONTENTSIZE_UNKNOWN = lib.ZSTD_CONTENTSIZE_UNKNOWN
+CONTENTSIZE_ERROR = lib.ZSTD_CONTENTSIZE_ERROR
+ZSTD_VERSION = (lib.ZSTD_VERSION_MAJOR, lib.ZSTD_VERSION_MINOR, lib.ZSTD_VERSION_RELEASE)
+BLOCKSIZELOG_MAX = lib.ZSTD_BLOCKSIZELOG_MAX
+BLOCKSIZE_MAX = lib.ZSTD_BLOCKSIZE_MAX
+WINDOWLOG_MIN = lib.ZSTD_WINDOWLOG_MIN
+WINDOWLOG_MAX = lib.ZSTD_WINDOWLOG_MAX
+CHAINLOG_MIN = lib.ZSTD_CHAINLOG_MIN
+CHAINLOG_MAX = lib.ZSTD_CHAINLOG_MAX
+HASHLOG_MIN = lib.ZSTD_HASHLOG_MIN
+HASHLOG_MAX = lib.ZSTD_HASHLOG_MAX
+HASHLOG3_MAX = lib.ZSTD_HASHLOG3_MAX
+MINMATCH_MIN = lib.ZSTD_MINMATCH_MIN
+MINMATCH_MAX = lib.ZSTD_MINMATCH_MAX
+SEARCHLOG_MIN = lib.ZSTD_SEARCHLOG_MIN
+SEARCHLOG_MAX = lib.ZSTD_SEARCHLOG_MAX
+SEARCHLENGTH_MIN = lib.ZSTD_MINMATCH_MIN
+SEARCHLENGTH_MAX = lib.ZSTD_MINMATCH_MAX
+TARGETLENGTH_MIN = lib.ZSTD_TARGETLENGTH_MIN
+TARGETLENGTH_MAX = lib.ZSTD_TARGETLENGTH_MAX
+LDM_MINMATCH_MIN = lib.ZSTD_LDM_MINMATCH_MIN
+LDM_MINMATCH_MAX = lib.ZSTD_LDM_MINMATCH_MAX
+LDM_BUCKETSIZELOG_MAX = lib.ZSTD_LDM_BUCKETSIZELOG_MAX
+STRATEGY_FAST = lib.ZSTD_fast
+STRATEGY_DFAST = lib.ZSTD_dfast
+STRATEGY_GREEDY = lib.ZSTD_greedy
+STRATEGY_LAZY = lib.ZSTD_lazy
+STRATEGY_LAZY2 = lib.ZSTD_lazy2
+STRATEGY_BTLAZY2 = lib.ZSTD_btlazy2
+STRATEGY_BTOPT = lib.ZSTD_btopt
+STRATEGY_BTULTRA = lib.ZSTD_btultra
+STRATEGY_BTULTRA2 = lib.ZSTD_btultra2
+DICT_TYPE_AUTO = lib.ZSTD_dct_auto
+DICT_TYPE_RAWCONTENT = lib.ZSTD_dct_rawContent
+DICT_TYPE_FULLDICT = lib.ZSTD_dct_fullDict
+FORMAT_ZSTD1 = lib.ZSTD_f_zstd1
+FORMAT_ZSTD1_MAGICLESS = lib.ZSTD_f_zstd1_magicless
+FLUSH_BLOCK = 0
+FLUSH_FRAME = 1
+COMPRESSOBJ_FLUSH_FINISH = 0
+COMPRESSOBJ_FLUSH_BLOCK = 1
+def _cpu_count():
+# os.cpu_count() was introducd in Python 3.4.
+try:
+return os.cpu_count() or 0
+except AttributeError:
+pass
+# Linux.
+try:
+if sys.version_info[0] == 2:
+return os.sysconf(b'SC_NPROCESSORS_ONLN')
+else:
+return os.sysconf(u'SC_NPROCESSORS_ONLN')
+except (AttributeError, ValueError):
+pass
+# TODO implement on other platforms.
+return 0
+class ZstdError(Exception):
+pass
+def _zstd_error(zresult):
+# Resolves to bytes on Python 2 and 3. We use the string for formatting
+# into error messages, which will be literal unicode. So convert it to
+# unicode.
+return ffi.string(lib.ZSTD_getErrorName(zresult)).decode('utf-8')
+def _make_cctx_params(params):
+res = lib.ZSTD_createCCtxParams()
+if res == ffi.NULL:
+raise MemoryError()
+res = ffi.gc(res, lib.ZSTD_freeCCtxParams)
+attrs = [
+(lib.ZSTD_c_format, params.format),
+(lib.ZSTD_c_compressionLevel, params.compression_level),
+(lib.ZSTD_c_windowLog, params.window_log),
+(lib.ZSTD_c_hashLog, params.hash_log),
+(lib.ZSTD_c_chainLog, params.chain_log),
+(lib.ZSTD_c_searchLog, params.search_log),
+(lib.ZSTD_c_minMatch, params.min_match),
+(lib.ZSTD_c_targetLength, params.target_length),
+(lib.ZSTD_c_strategy, params.compression_strategy),
+(lib.ZSTD_c_contentSizeFlag, params.write_content_size),
+(lib.ZSTD_c_checksumFlag, params.write_checksum),
+(lib.ZSTD_c_dictIDFlag, params.write_dict_id),
+(lib.ZSTD_c_nbWorkers, params.threads),
+(lib.ZSTD_c_jobSize, params.job_size),
+(lib.ZSTD_c_overlapLog, params.overlap_log),
+(lib.ZSTD_c_forceMaxWindow, params.force_max_window),
+(lib.ZSTD_c_enableLongDistanceMatching, params.enable_ldm),
+(lib.ZSTD_c_ldmHashLog, params.ldm_hash_log),
+(lib.ZSTD_c_ldmMinMatch, params.ldm_min_match),
+(lib.ZSTD_c_ldmBucketSizeLog, params.ldm_bucket_size_log),
+(lib.ZSTD_c_ldmHashRateLog, params.ldm_hash_rate_log),
+]
+for param, value in attrs:
+_set_compression_parameter(res, param, value)
+return res
+class ZstdCompressionParameters(object):
+@staticmethod
+def from_level(level, source_size=0, dict_size=0, **kwargs):
+params = lib.ZSTD_getCParams(level, source_size, dict_size)
+args = {
+'window_log': 'windowLog',
+'chain_log': 'chainLog',
+'hash_log': 'hashLog',
+'search_log': 'searchLog',
+'min_match': 'minMatch',
+'target_length': 'targetLength',
+'compression_strategy': 'strategy',
+}
+for arg, attr in args.items():
+if arg not in kwargs:
+kwargs[arg] = getattr(params, attr)
+return ZstdCompressionParameters(**kwargs)
+def __init__(self, format=0, compression_level=0, window_log=0, hash_log=0,
+chain_log=0, search_log=0, min_match=0, target_length=0,
+strategy=-1, compression_strategy=-1,
+write_content_size=1, write_checksum=0,
+write_dict_id=0, job_size=0, overlap_log=-1,
+overlap_size_log=-1, force_max_window=0, enable_ldm=0,
+ldm_hash_log=0, ldm_min_match=0, ldm_bucket_size_log=0,
+ldm_hash_rate_log=-1, ldm_hash_every_log=-1, threads=0):
+params = lib.ZSTD_createCCtxParams()
+if params == ffi.NULL:
+raise MemoryError()
+params = ffi.gc(params, lib.ZSTD_freeCCtxParams)
+self._params = params
+if threads < 0:
+threads = _cpu_count()
+# We need to set ZSTD_c_nbWorkers before ZSTD_c_jobSize and ZSTD_c_overlapLog
+# because setting ZSTD_c_nbWorkers resets the other parameters.
+_set_compression_parameter(params, lib.ZSTD_c_nbWorkers, threads)
+_set_compression_parameter(params, lib.ZSTD_c_format, format)
+_set_compression_parameter(params, lib.ZSTD_c_compressionLevel, compression_level)
+_set_compression_parameter(params, lib.ZSTD_c_windowLog, window_log)
+_set_compression_parameter(params, lib.ZSTD_c_hashLog, hash_log)
+_set_compression_parameter(params, lib.ZSTD_c_chainLog, chain_log)
+_set_compression_parameter(params, lib.ZSTD_c_searchLog, search_log)
+_set_compression_parameter(params, lib.ZSTD_c_minMatch, min_match)
+_set_compression_parameter(params, lib.ZSTD_c_targetLength, target_length)
+if strategy != -1 and compression_strategy != -1:
+raise ValueError('cannot specify both compression_strategy and strategy')
+if compression_strategy != -1:
+strategy = compression_strategy
+elif strategy == -1:
+strategy = 0
+_set_compression_parameter(params, lib.ZSTD_c_strategy, strategy)
+_set_compression_parameter(params, lib.ZSTD_c_contentSizeFlag, write_content_size)
+_set_compression_parameter(params, lib.ZSTD_c_checksumFlag, write_checksum)
+_set_compression_parameter(params, lib.ZSTD_c_dictIDFlag, write_dict_id)
+_set_compression_parameter(params, lib.ZSTD_c_jobSize, job_size)
+if overlap_log != -1 and overlap_size_log != -1:
+raise ValueError('cannot specify both overlap_log and overlap_size_log')
+if overlap_size_log != -1:
+overlap_log = overlap_size_log
+elif overlap_log == -1:
+overlap_log = 0
+_set_compression_parameter(params, lib.ZSTD_c_overlapLog, overlap_log)
+_set_compression_parameter(params, lib.ZSTD_c_forceMaxWindow, force_max_window)
+_set_compression_parameter(params, lib.ZSTD_c_enableLongDistanceMatching, enable_ldm)
+_set_compression_parameter(params, lib.ZSTD_c_ldmHashLog, ldm_hash_log)
+_set_compression_parameter(params, lib.ZSTD_c_ldmMinMatch, ldm_min_match)
+_set_compression_parameter(params, lib.ZSTD_c_ldmBucketSizeLog, ldm_bucket_size_log)
+if ldm_hash_rate_log != -1 and ldm_hash_every_log != -1:
+raise ValueError('cannot specify both ldm_hash_rate_log and ldm_hash_every_log')
+if ldm_hash_every_log != -1:
+ldm_hash_rate_log = ldm_hash_every_log
+elif ldm_hash_rate_log == -1:
+ldm_hash_rate_log = 0
+_set_compression_parameter(params, lib.ZSTD_c_ldmHashRateLog, ldm_hash_rate_log)
+@property
+def format(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_format)
+@property
+def compression_level(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_compressionLevel)
+@property
+def window_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_windowLog)
+@property
+def hash_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_hashLog)
+@property
+def chain_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_chainLog)
+@property
+def search_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_searchLog)
+@property
+def min_match(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_minMatch)
+@property
+def target_length(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_targetLength)
+@property
+def compression_strategy(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_strategy)
+@property
+def write_content_size(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_contentSizeFlag)
+@property
+def write_checksum(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_checksumFlag)
+@property
+def write_dict_id(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_dictIDFlag)
+@property
+def job_size(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_jobSize)
+@property
+def overlap_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_overlapLog)
+@property
+def overlap_size_log(self):
+return self.overlap_log
+@property
+def force_max_window(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_forceMaxWindow)
+@property
+def enable_ldm(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_enableLongDistanceMatching)
+@property
+def ldm_hash_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_ldmHashLog)
+@property
+def ldm_min_match(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_ldmMinMatch)
+@property
+def ldm_bucket_size_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_ldmBucketSizeLog)
+@property
+def ldm_hash_rate_log(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_ldmHashRateLog)
+@property
+def ldm_hash_every_log(self):
+return self.ldm_hash_rate_log
+@property
+def threads(self):
+return _get_compression_parameter(self._params, lib.ZSTD_c_nbWorkers)
+def estimated_compression_context_size(self):
+return lib.ZSTD_estimateCCtxSize_usingCCtxParams(self._params)
+CompressionParameters = ZstdCompressionParameters
+def estimate_decompression_context_size():
+return lib.ZSTD_estimateDCtxSize()
+def _set_compression_parameter(params, param, value):
+zresult = lib.ZSTD_CCtxParam_setParameter(params, param, value)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('unable to set compression context parameter: %s' %
+_zstd_error(zresult))
+def _get_compression_parameter(params, param):
+result = ffi.new('int *')
+zresult = lib.ZSTD_CCtxParam_getParameter(params, param, result)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('unable to get compression context parameter: %s' %
+_zstd_error(zresult))
+return result[0]
+class ZstdCompressionWriter(object):
+def __init__(self, compressor, writer, source_size, write_size,
+write_return_read):
+self._compressor = compressor
+self._writer = writer
+self._write_size = write_size
+self._write_return_read = bool(write_return_read)
+self._entered = False
+self._closed = False
+self._bytes_compressed = 0
+self._dst_buffer = ffi.new('char[]', write_size)
+self._out_buffer = ffi.new('ZSTD_outBuffer *')
+self._out_buffer.dst = self._dst_buffer
+self._out_buffer.size = len(self._dst_buffer)
+self._out_buffer.pos = 0
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(compressor._cctx,
+source_size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+def __enter__(self):
+if self._closed:
+raise ValueError('stream is closed')
+if self._entered:
+raise ZstdError('cannot __enter__ multiple times')
+self._entered = True
+return self
+def __exit__(self, exc_type, exc_value, exc_tb):
+self._entered = False
+if not exc_type and not exc_value and not exc_tb:
+self.close()
+self._compressor = None
+return False
+def memory_size(self):
+return lib.ZSTD_sizeof_CCtx(self._compressor._cctx)
+def fileno(self):
+f = getattr(self._writer, 'fileno', None)
+if f:
+return f()
+else:
+raise OSError('fileno not available on underlying writer')
+def close(self):
+if self._closed:
+return
+try:
+self.flush(FLUSH_FRAME)
+finally:
+self._closed = True
+# Call close() on underlying stream as well.
+f = getattr(self._writer, 'close', None)
+if f:
+f()
+@property
+def closed(self):
+return self._closed
+def isatty(self):
+return False
+def readable(self):
+return False
+def readline(self, size=-1):
+raise io.UnsupportedOperation()
+def readlines(self, hint=-1):
+raise io.UnsupportedOperation()
+def seek(self, offset, whence=None):
+raise io.UnsupportedOperation()
+def seekable(self):
+return False
+def truncate(self, size=None):
+raise io.UnsupportedOperation()
+def writable(self):
+return True
+def writelines(self, lines):
+raise NotImplementedError('writelines() is not yet implemented')
+def read(self, size=-1):
+raise io.UnsupportedOperation()
+def readall(self):
+raise io.UnsupportedOperation()
+def readinto(self, b):
+raise io.UnsupportedOperation()
+def write(self, data):
+if self._closed:
+raise ValueError('stream is closed')
+total_write = 0
+data_buffer = ffi.from_buffer(data)
+in_buffer = ffi.new('ZSTD_inBuffer *')
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+out_buffer = self._out_buffer
+out_buffer.pos = 0
+while in_buffer.pos < in_buffer.size:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, in_buffer,
+lib.ZSTD_e_continue)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
+total_write += out_buffer.pos
+self._bytes_compressed += out_buffer.pos
+out_buffer.pos = 0
+if self._write_return_read:
+return in_buffer.pos
+else:
+return total_write
+def flush(self, flush_mode=FLUSH_BLOCK):
+if flush_mode == FLUSH_BLOCK:
+flush = lib.ZSTD_e_flush
+elif flush_mode == FLUSH_FRAME:
+flush = lib.ZSTD_e_end
+else:
+raise ValueError('unknown flush_mode: %r' % flush_mode)
+if self._closed:
+raise ValueError('stream is closed')
+total_write = 0
+out_buffer = self._out_buffer
+out_buffer.pos = 0
+in_buffer = ffi.new('ZSTD_inBuffer *')
+in_buffer.src = ffi.NULL
+in_buffer.size = 0
+in_buffer.pos = 0
+while True:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, in_buffer,
+flush)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
+total_write += out_buffer.pos
+self._bytes_compressed += out_buffer.pos
+out_buffer.pos = 0
+if not zresult:
+break
+return total_write
+def tell(self):
+return self._bytes_compressed
+class ZstdCompressionObj(object):
+def compress(self, data):
+if self._finished:
+raise ZstdError('cannot call compress() after compressor finished')
+data_buffer = ffi.from_buffer(data)
+source = ffi.new('ZSTD_inBuffer *')
+source.src = data_buffer
+source.size = len(data_buffer)
+source.pos = 0
+chunks = []
+while source.pos < len(data):
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+self._out,
+source,
+lib.ZSTD_e_continue)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if self._out.pos:
+chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:])
+self._out.pos = 0
+return b''.join(chunks)
+def flush(self, flush_mode=COMPRESSOBJ_FLUSH_FINISH):
+if flush_mode not in (COMPRESSOBJ_FLUSH_FINISH, COMPRESSOBJ_FLUSH_BLOCK):
+raise ValueError('flush mode not recognized')
+if self._finished:
+raise ZstdError('compressor object already finished')
+if flush_mode == COMPRESSOBJ_FLUSH_BLOCK:
+z_flush_mode = lib.ZSTD_e_flush
+elif flush_mode == COMPRESSOBJ_FLUSH_FINISH:
+z_flush_mode = lib.ZSTD_e_end
+self._finished = True
+else:
+raise ZstdError('unhandled flush mode')
+assert self._out.pos == 0
+in_buffer = ffi.new('ZSTD_inBuffer *')
+in_buffer.src = ffi.NULL
+in_buffer.size = 0
+in_buffer.pos = 0
+chunks = []
+while True:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+self._out,
+in_buffer,
+z_flush_mode)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s' %
+_zstd_error(zresult))
+if self._out.pos:
+chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:])
+self._out.pos = 0
+if not zresult:
+break
+return b''.join(chunks)
+class ZstdCompressionChunker(object):
+def __init__(self, compressor, chunk_size):
+self._compressor = compressor
+self._out = ffi.new('ZSTD_outBuffer *')
+self._dst_buffer = ffi.new('char[]', chunk_size)
+self._out.dst = self._dst_buffer
+self._out.size = chunk_size
+self._out.pos = 0
+self._in = ffi.new('ZSTD_inBuffer *')
+self._in.src = ffi.NULL
+self._in.size = 0
+self._in.pos = 0
+self._finished = False
+def compress(self, data):
+if self._finished:
+raise ZstdError('cannot call compress() after compression finished')
+if self._in.src != ffi.NULL:
+raise ZstdError('cannot perform operation before consuming output '
+'from previous operation')
+data_buffer = ffi.from_buffer(data)
+if not len(data_buffer):
+return
+self._in.src = data_buffer
+self._in.size = len(data_buffer)
+self._in.pos = 0
+while self._in.pos < self._in.size:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+self._out,
+self._in,
+lib.ZSTD_e_continue)
+if self._in.pos == self._in.size:
+self._in.src = ffi.NULL
+self._in.size = 0
+self._in.pos = 0
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if self._out.pos == self._out.size:
+yield ffi.buffer(self._out.dst, self._out.pos)[:]
+self._out.pos = 0
+def flush(self):
+if self._finished:
+raise ZstdError('cannot call flush() after compression finished')
+if self._in.src != ffi.NULL:
+raise ZstdError('cannot call flush() before consuming output from '
+'previous operation')
+while True:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+self._out, self._in,
+lib.ZSTD_e_flush)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' % _zstd_error(zresult))
+if self._out.pos:
+yield ffi.buffer(self._out.dst, self._out.pos)[:]
+self._out.pos = 0
+if not zresult:
+return
+def finish(self):
+if self._finished:
+raise ZstdError('cannot call finish() after compression finished')
+if self._in.src != ffi.NULL:
+raise ZstdError('cannot call finish() before consuming output from '
+'previous operation')
+while True:
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+self._out, self._in,
+lib.ZSTD_e_end)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' % _zstd_error(zresult))
+if self._out.pos:
+yield ffi.buffer(self._out.dst, self._out.pos)[:]
+self._out.pos = 0
+if not zresult:
+self._finished = True
+return
+class ZstdCompressionReader(object):
+def __init__(self, compressor, source, read_size):
+self._compressor = compressor
+self._source = source
+self._read_size = read_size
+self._entered = False
+self._closed = False
+self._bytes_compressed = 0
+self._finished_input = False
+self._finished_output = False
+self._in_buffer = ffi.new('ZSTD_inBuffer *')
+# Holds a ref so backing bytes in self._in_buffer stay alive.
+self._source_buffer = None
+def __enter__(self):
+if self._entered:
+raise ValueError('cannot __enter__ multiple times')
+self._entered = True
+return self
+def __exit__(self, exc_type, exc_value, exc_tb):
+self._entered = False
+self._closed = True
+self._source = None
+self._compressor = None
+return False
+def readable(self):
+return True
+def writable(self):
+return False
+def seekable(self):
+return False
+def readline(self):
+raise io.UnsupportedOperation()
+def readlines(self):
+raise io.UnsupportedOperation()
+def write(self, data):
+raise OSError('stream is not writable')
+def writelines(self, ignored):
+raise OSError('stream is not writable')
+def isatty(self):
+return False
+def flush(self):
+return None
+def close(self):
+self._closed = True
+return None
+@property
+def closed(self):
+return self._closed
+def tell(self):
+return self._bytes_compressed
+def readall(self):
+chunks = []
+while True:
+chunk = self.read(1048576)
+if not chunk:
+break
+chunks.append(chunk)
+return b''.join(chunks)
+def __iter__(self):
+raise io.UnsupportedOperation()
+def __next__(self):
+raise io.UnsupportedOperation()
+next = __next__
+def _read_input(self):
+if self._finished_input:
+return
+if hasattr(self._source, 'read'):
+data = self._source.read(self._read_size)
+if not data:
+self._finished_input = True
+return
+self._source_buffer = ffi.from_buffer(data)
+self._in_buffer.src = self._source_buffer
+self._in_buffer.size = len(self._source_buffer)
+self._in_buffer.pos = 0
+else:
+self._source_buffer = ffi.from_buffer(self._source)
+self._in_buffer.src = self._source_buffer
+self._in_buffer.size = len(self._source_buffer)
+self._in_buffer.pos = 0
+def _compress_into_buffer(self, out_buffer):
+if self._in_buffer.pos >= self._in_buffer.size:
+return
+old_pos = out_buffer.pos
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, self._in_buffer,
+lib.ZSTD_e_continue)
+self._bytes_compressed += out_buffer.pos - old_pos
+if self._in_buffer.pos == self._in_buffer.size:
+self._in_buffer.src = ffi.NULL
+self._in_buffer.pos = 0
+self._in_buffer.size = 0
+self._source_buffer = None
+if not hasattr(self._source, 'read'):
+self._finished_input = True
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s',
+_zstd_error(zresult))
+return out_buffer.pos and out_buffer.pos == out_buffer.size
+def read(self, size=-1):
+if self._closed:
+raise ValueError('stream is closed')
+if size < -1:
+raise ValueError('cannot read negative amounts less than -1')
+if size == -1:
+return self.readall()
+if self._finished_output or size == 0:
+return b''
+# Need a dedicated ref to dest buffer otherwise it gets collected.
+dst_buffer = ffi.new('char[]', size)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dst_buffer
+out_buffer.size = size
+out_buffer.pos = 0
+if self._compress_into_buffer(out_buffer):
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+while not self._finished_input:
+self._read_input()
+if self._compress_into_buffer(out_buffer):
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+# EOF
+old_pos = out_buffer.pos
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, self._in_buffer,
+lib.ZSTD_e_end)
+self._bytes_compressed += out_buffer.pos - old_pos
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s',
+_zstd_error(zresult))
+if zresult == 0:
+self._finished_output = True
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+def read1(self, size=-1):
+if self._closed:
+raise ValueError('stream is closed')
+if size < -1:
+raise ValueError('cannot read negative amounts less than -1')
+if self._finished_output or size == 0:
+return b''
+# -1 returns arbitrary number of bytes.
+if size == -1:
+size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+dst_buffer = ffi.new('char[]', size)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dst_buffer
+out_buffer.size = size
+out_buffer.pos = 0
+# read1() dictates that we can perform at most 1 call to the
+# underlying stream to get input. However, we can't satisfy this
+# restriction with compression because not all input generates output.
+# It is possible to perform a block flush in order to ensure output.
+# But this may not be desirable behavior. So we allow multiple read()
+# to the underlying stream. But unlike read(), we stop once we have
+# any output.
+self._compress_into_buffer(out_buffer)
+if out_buffer.pos:
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+while not self._finished_input:
+self._read_input()
+# If we've filled the output buffer, return immediately.
+if self._compress_into_buffer(out_buffer):
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+# If we've populated the output buffer and we're not at EOF,
+# also return, as we've satisfied the read1() limits.
+if out_buffer.pos and not self._finished_input:
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+# Else if we're at EOS and we have room left in the buffer,
+# fall through to below and try to add more data to the output.
+# EOF.
+old_pos = out_buffer.pos
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, self._in_buffer,
+lib.ZSTD_e_end)
+self._bytes_compressed += out_buffer.pos - old_pos
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s' %
+_zstd_error(zresult))
+if zresult == 0:
+self._finished_output = True
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+def readinto(self, b):
+if self._closed:
+raise ValueError('stream is closed')
+if self._finished_output:
+return 0
+# TODO use writable=True once we require CFFI >= 1.12.
+dest_buffer = ffi.from_buffer(b)
+ffi.memmove(b, b'', 0)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dest_buffer
+out_buffer.size = len(dest_buffer)
+out_buffer.pos = 0
+if self._compress_into_buffer(out_buffer):
+return out_buffer.pos
+while not self._finished_input:
+self._read_input()
+if self._compress_into_buffer(out_buffer):
+return out_buffer.pos
+# EOF.
+old_pos = out_buffer.pos
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, self._in_buffer,
+lib.ZSTD_e_end)
+self._bytes_compressed += out_buffer.pos - old_pos
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s',
+_zstd_error(zresult))
+if zresult == 0:
+self._finished_output = True
+return out_buffer.pos
+def readinto1(self, b):
+if self._closed:
+raise ValueError('stream is closed')
+if self._finished_output:
+return 0
+# TODO use writable=True once we require CFFI >= 1.12.
+dest_buffer = ffi.from_buffer(b)
+ffi.memmove(b, b'', 0)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dest_buffer
+out_buffer.size = len(dest_buffer)
+out_buffer.pos = 0
+self._compress_into_buffer(out_buffer)
+if out_buffer.pos:
+return out_buffer.pos
+while not self._finished_input:
+self._read_input()
+if self._compress_into_buffer(out_buffer):
+return out_buffer.pos
+if out_buffer.pos and not self._finished_input:
+return out_buffer.pos
+# EOF.
+old_pos = out_buffer.pos
+zresult = lib.ZSTD_compressStream2(self._compressor._cctx,
+out_buffer, self._in_buffer,
+lib.ZSTD_e_end)
+self._bytes_compressed += out_buffer.pos - old_pos
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s' %
+_zstd_error(zresult))
+if zresult == 0:
+self._finished_output = True
+return out_buffer.pos
+class ZstdCompressor(object):
+def __init__(self, level=3, dict_data=None, compression_params=None,
+write_checksum=None, write_content_size=None,
+write_dict_id=None, threads=0):
+if level > lib.ZSTD_maxCLevel():
+raise ValueError('level must be less than %d' % lib.ZSTD_maxCLevel())
+if threads < 0:
+threads = _cpu_count()
+if compression_params and write_checksum is not None:
+raise ValueError('cannot define compression_params and '
+'write_checksum')
+if compression_params and write_content_size is not None:
+raise ValueError('cannot define compression_params and '
+'write_content_size')
+if compression_params and write_dict_id is not None:
+raise ValueError('cannot define compression_params and '
+'write_dict_id')
+if compression_params and threads:
+raise ValueError('cannot define compression_params and threads')
+if compression_params:
+self._params = _make_cctx_params(compression_params)
+else:
+if write_dict_id is None:
+write_dict_id = True
+params = lib.ZSTD_createCCtxParams()
+if params == ffi.NULL:
+raise MemoryError()
+self._params = ffi.gc(params, lib.ZSTD_freeCCtxParams)
+_set_compression_parameter(self._params,
+lib.ZSTD_c_compressionLevel,
+level)
+_set_compression_parameter(
+self._params,
+lib.ZSTD_c_contentSizeFlag,
+write_content_size if write_content_size is not None else 1)
+_set_compression_parameter(self._params,
+lib.ZSTD_c_checksumFlag,
+1 if write_checksum else 0)
+_set_compression_parameter(self._params,
+lib.ZSTD_c_dictIDFlag,
+1 if write_dict_id else 0)
+if threads:
+_set_compression_parameter(self._params,
+lib.ZSTD_c_nbWorkers,
+threads)
+cctx = lib.ZSTD_createCCtx()
+if cctx == ffi.NULL:
+raise MemoryError()
+self._cctx = cctx
+self._dict_data = dict_data
+# We defer setting up garbage collection until after calling
+# _setup_cctx() to ensure the memory size estimate is more accurate.
+try:
+self._setup_cctx()
+finally:
+self._cctx = ffi.gc(cctx, lib.ZSTD_freeCCtx,
+size=lib.ZSTD_sizeof_CCtx(cctx))
+def _setup_cctx(self):
+zresult = lib.ZSTD_CCtx_setParametersUsingCCtxParams(self._cctx,
+self._params)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('could not set compression parameters: %s' %
+_zstd_error(zresult))
+dict_data = self._dict_data
+if dict_data:
+if dict_data._cdict:
+zresult = lib.ZSTD_CCtx_refCDict(self._cctx, dict_data._cdict)
+else:
+zresult = lib.ZSTD_CCtx_loadDictionary_advanced(
+self._cctx, dict_data.as_bytes(), len(dict_data),
+lib.ZSTD_dlm_byRef, dict_data._dict_type)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('could not load compression dictionary: %s' %
+_zstd_error(zresult))
+def memory_size(self):
+return lib.ZSTD_sizeof_CCtx(self._cctx)
+def compress(self, data):
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+data_buffer = ffi.from_buffer(data)
+dest_size = lib.ZSTD_compressBound(len(data_buffer))
+out = new_nonzero('char[]', dest_size)
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, len(data_buffer))
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+out_buffer = ffi.new('ZSTD_outBuffer *')
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer.dst = out
+out_buffer.size = dest_size
+out_buffer.pos = 0
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+zresult = lib.ZSTD_compressStream2(self._cctx,
+out_buffer,
+in_buffer,
+lib.ZSTD_e_end)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('cannot compress: %s' %
+_zstd_error(zresult))
+elif zresult:
+raise ZstdError('unexpected partial frame flush')
+return ffi.buffer(out, out_buffer.pos)[:]
+def compressobj(self, size=-1):
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+cobj = ZstdCompressionObj()
+cobj._out = ffi.new('ZSTD_outBuffer *')
+cobj._dst_buffer = ffi.new('char[]', COMPRESSION_RECOMMENDED_OUTPUT_SIZE)
+cobj._out.dst = cobj._dst_buffer
+cobj._out.size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+cobj._out.pos = 0
+cobj._compressor = self
+cobj._finished = False
+return cobj
+def chunker(self, size=-1, chunk_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+return ZstdCompressionChunker(self, chunk_size=chunk_size)
+def copy_stream(self, ifh, ofh, size=-1,
+read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE,
+write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
+if not hasattr(ifh, 'read'):
+raise ValueError('first argument must have a read() method')
+if not hasattr(ofh, 'write'):
+raise ValueError('second argument must have a write() method')
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+dst_buffer = ffi.new('char[]', write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = write_size
+out_buffer.pos = 0
+total_read, total_write = 0, 0
+while True:
+data = ifh.read(read_size)
+if not data:
+break
+data_buffer = ffi.from_buffer(data)
+total_read += len(data_buffer)
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+while in_buffer.pos < in_buffer.size:
+zresult = lib.ZSTD_compressStream2(self._cctx,
+out_buffer,
+in_buffer,
+lib.ZSTD_e_continue)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
+total_write += out_buffer.pos
+out_buffer.pos = 0
+# We've finished reading. Flush the compressor.
+while True:
+zresult = lib.ZSTD_compressStream2(self._cctx,
+out_buffer,
+in_buffer,
+lib.ZSTD_e_end)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
+total_write += out_buffer.pos
+out_buffer.pos = 0
+if zresult == 0:
+break
+return total_read, total_write
+def stream_reader(self, source, size=-1,
+read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE):
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+try:
+size = len(source)
+except Exception:
+pass
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+return ZstdCompressionReader(self, source, read_size)
+def stream_writer(self, writer, size=-1,
+write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE,
+write_return_read=False):
+if not hasattr(writer, 'write'):
+raise ValueError('must pass an object with a write() method')
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+return ZstdCompressionWriter(self, writer, size, write_size,
+write_return_read)
+write_to = stream_writer
+def read_to_iter(self, reader, size=-1,
+read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE,
+write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE):
+if hasattr(reader, 'read'):
+have_read = True
+elif hasattr(reader, '__getitem__'):
+have_read = False
+buffer_offset = 0
+size = len(reader)
+else:
+raise ValueError('must pass an object with a read() method or '
+'conforms to buffer protocol')
+lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only)
+if size < 0:
+size = lib.ZSTD_CONTENTSIZE_UNKNOWN
+zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error setting source size: %s' %
+_zstd_error(zresult))
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+in_buffer.src = ffi.NULL
+in_buffer.size = 0
+in_buffer.pos = 0
+dst_buffer = ffi.new('char[]', write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = write_size
+out_buffer.pos = 0
+while True:
+# We should never have output data sitting around after a previous
+# iteration.
+assert out_buffer.pos == 0
+# Collect input data.
+if have_read:
+read_result = reader.read(read_size)
+else:
+remaining = len(reader) - buffer_offset
+slice_size = min(remaining, read_size)
+read_result = reader[buffer_offset:buffer_offset + slice_size]
+buffer_offset += slice_size
+# No new input data. Break out of the read loop.
+if not read_result:
+break
+# Feed all read data into the compressor and emit output until
+# exhausted.
+read_buffer = ffi.from_buffer(read_result)
+in_buffer.src = read_buffer
+in_buffer.size = len(read_buffer)
+in_buffer.pos = 0
+while in_buffer.pos < in_buffer.size:
+zresult = lib.ZSTD_compressStream2(self._cctx, out_buffer, in_buffer,
+lib.ZSTD_e_continue)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd compress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+out_buffer.pos = 0
+yield data
+assert out_buffer.pos == 0
+# And repeat the loop to collect more data.
+continue
+# If we get here, input is exhausted. End the stream and emit what
+# remains.
+while True:
+assert out_buffer.pos == 0
+zresult = lib.ZSTD_compressStream2(self._cctx,
+out_buffer,
+in_buffer,
+lib.ZSTD_e_end)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('error ending compression stream: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+out_buffer.pos = 0
+yield data
+if zresult == 0:
+break
+read_from = read_to_iter
+def frame_progression(self):
+progression = lib.ZSTD_getFrameProgression(self._cctx)
+return progression.ingested, progression.consumed, progression.produced
+class FrameParameters(object):
+def __init__(self, fparams):
+self.content_size = fparams.frameContentSize
+self.window_size = fparams.windowSize
+self.dict_id = fparams.dictID
+self.has_checksum = bool(fparams.checksumFlag)
+def frame_content_size(data):
+data_buffer = ffi.from_buffer(data)
+size = lib.ZSTD_getFrameContentSize(data_buffer, len(data_buffer))
+if size == lib.ZSTD_CONTENTSIZE_ERROR:
+raise ZstdError('error when determining content size')
+elif size == lib.ZSTD_CONTENTSIZE_UNKNOWN:
+return -1
+else:
+return size
+def frame_header_size(data):
+data_buffer = ffi.from_buffer(data)
+zresult = lib.ZSTD_frameHeaderSize(data_buffer, len(data_buffer))
+if lib.ZSTD_isError(zresult):
+raise ZstdError('could not determine frame header size: %s' %
+_zstd_error(zresult))
+return zresult
+def get_frame_parameters(data):
+params = ffi.new('ZSTD_frameHeader *')
+data_buffer = ffi.from_buffer(data)
+zresult = lib.ZSTD_getFrameHeader(params, data_buffer, len(data_buffer))
+if lib.ZSTD_isError(zresult):
+raise ZstdError('cannot get frame parameters: %s' %
+_zstd_error(zresult))
+if zresult:
+raise ZstdError('not enough data for frame parameters; need %d bytes' %
+zresult)
+return FrameParameters(params[0])
+class ZstdCompressionDict(object):
+def __init__(self, data, dict_type=DICT_TYPE_AUTO, k=0, d=0):
+assert isinstance(data, bytes_type)
+self._data = data
+self.k = k
+self.d = d
+if dict_type not in (DICT_TYPE_AUTO, DICT_TYPE_RAWCONTENT,
+DICT_TYPE_FULLDICT):
+raise ValueError('invalid dictionary load mode: %d; must use '
+'DICT_TYPE_* constants')
+self._dict_type = dict_type
+self._cdict = None
+def __len__(self):
+return len(self._data)
+def dict_id(self):
+return int_type(lib.ZDICT_getDictID(self._data, len(self._data)))
+def as_bytes(self):
+return self._data
+def precompute_compress(self, level=0, compression_params=None):
+if level and compression_params:
+raise ValueError('must only specify one of level or '
+'compression_params')
+if not level and not compression_params:
+raise ValueError('must specify one of level or compression_params')
+if level:
+cparams = lib.ZSTD_getCParams(level, 0, len(self._data))
+else:
+cparams = ffi.new('ZSTD_compressionParameters')
+cparams.chainLog = compression_params.chain_log
+cparams.hashLog = compression_params.hash_log
+cparams.minMatch = compression_params.min_match
+cparams.searchLog = compression_params.search_log
+cparams.strategy = compression_params.compression_strategy
+cparams.targetLength = compression_params.target_length
+cparams.windowLog = compression_params.window_log
+cdict = lib.ZSTD_createCDict_advanced(self._data, len(self._data),
+lib.ZSTD_dlm_byRef,
+self._dict_type,
+cparams,
+lib.ZSTD_defaultCMem)
+if cdict == ffi.NULL:
+raise ZstdError('unable to precompute dictionary')
+self._cdict = ffi.gc(cdict, lib.ZSTD_freeCDict,
+size=lib.ZSTD_sizeof_CDict(cdict))
+@property
+def _ddict(self):
+ddict = lib.ZSTD_createDDict_advanced(self._data, len(self._data),
+lib.ZSTD_dlm_byRef,
+self._dict_type,
+lib.ZSTD_defaultCMem)
+if ddict == ffi.NULL:
+raise ZstdError('could not create decompression dict')
+ddict = ffi.gc(ddict, lib.ZSTD_freeDDict,
+size=lib.ZSTD_sizeof_DDict(ddict))
+self.__dict__['_ddict'] = ddict
+return ddict
+def train_dictionary(dict_size, samples, k=0, d=0, notifications=0, dict_id=0,
+level=0, steps=0, threads=0):
+if not isinstance(samples, list):
+raise TypeError('samples must be a list')
+if threads < 0:
+threads = _cpu_count()
+total_size = sum(map(len, samples))
+samples_buffer = new_nonzero('char[]', total_size)
+sample_sizes = new_nonzero('size_t[]', len(samples))
+offset = 0
+for i, sample in enumerate(samples):
+if not isinstance(sample, bytes_type):
+raise ValueError('samples must be bytes')
+l = len(sample)
+ffi.memmove(samples_buffer + offset, sample, l)
+offset += l
+sample_sizes[i] = l
+dict_data = new_nonzero('char[]', dict_size)
+dparams = ffi.new('ZDICT_cover_params_t *')[0]
+dparams.k = k
+dparams.d = d
+dparams.steps = steps
+dparams.nbThreads = threads
+dparams.zParams.notificationLevel = notifications
+dparams.zParams.dictID = dict_id
+dparams.zParams.compressionLevel = level
+if (not dparams.k and not dparams.d and not dparams.steps
+and not dparams.nbThreads and not dparams.zParams.notificationLevel
+and not dparams.zParams.dictID
+and not dparams.zParams.compressionLevel):
+zresult = lib.ZDICT_trainFromBuffer(
+ffi.addressof(dict_data), dict_size,
+ffi.addressof(samples_buffer),
+ffi.addressof(sample_sizes, 0), len(samples))
+elif dparams.steps or dparams.nbThreads:
+zresult = lib.ZDICT_optimizeTrainFromBuffer_cover(
+ffi.addressof(dict_data), dict_size,
+ffi.addressof(samples_buffer),
+ffi.addressof(sample_sizes, 0), len(samples),
+ffi.addressof(dparams))
+else:
+zresult = lib.ZDICT_trainFromBuffer_cover(
+ffi.addressof(dict_data), dict_size,
+ffi.addressof(samples_buffer),
+ffi.addressof(sample_sizes, 0), len(samples),
+dparams)
+if lib.ZDICT_isError(zresult):
+msg = ffi.string(lib.ZDICT_getErrorName(zresult)).decode('utf-8')
+raise ZstdError('cannot train dict: %s' % msg)
+return ZstdCompressionDict(ffi.buffer(dict_data, zresult)[:],
+dict_type=DICT_TYPE_FULLDICT,
+k=dparams.k, d=dparams.d)
+class ZstdDecompressionObj(object):
+def __init__(self, decompressor, write_size):
+self._decompressor = decompressor
+self._write_size = write_size
+self._finished = False
+def decompress(self, data):
+if self._finished:
+raise ZstdError('cannot use a decompressobj multiple times')
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+data_buffer = ffi.from_buffer(data)
+if len(data_buffer) == 0:
+return b''
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+dst_buffer = ffi.new('char[]', self._write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = len(dst_buffer)
+out_buffer.pos = 0
+chunks = []
+while True:
+zresult = lib.ZSTD_decompressStream(self._decompressor._dctx,
+out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd decompressor error: %s' %
+_zstd_error(zresult))
+if zresult == 0:
+self._finished = True
+self._decompressor = None
+if out_buffer.pos:
+chunks.append(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
+if (zresult == 0 or
+(in_buffer.pos == in_buffer.size and out_buffer.pos == 0)):
+break
+out_buffer.pos = 0
+return b''.join(chunks)
+def flush(self, length=0):
+pass
+class ZstdDecompressionReader(object):
+def __init__(self, decompressor, source, read_size, read_across_frames):
+self._decompressor = decompressor
+self._source = source
+self._read_size = read_size
+self._read_across_frames = bool(read_across_frames)
+self._entered = False
+self._closed = False
+self._bytes_decompressed = 0
+self._finished_input = False
+self._finished_output = False
+self._in_buffer = ffi.new('ZSTD_inBuffer *')
+# Holds a ref to self._in_buffer.src.
+self._source_buffer = None
+def __enter__(self):
+if self._entered:
+raise ValueError('cannot __enter__ multiple times')
+self._entered = True
+return self
+def __exit__(self, exc_type, exc_value, exc_tb):
+self._entered = False
+self._closed = True
+self._source = None
+self._decompressor = None
+return False
+def readable(self):
+return True
+def writable(self):
+return False
+def seekable(self):
+return True
+def readline(self):
+raise io.UnsupportedOperation()
+def readlines(self):
+raise io.UnsupportedOperation()
+def write(self, data):
+raise io.UnsupportedOperation()
+def writelines(self, lines):
+raise io.UnsupportedOperation()
+def isatty(self):
+return False
+def flush(self):
+return None
+def close(self):
+self._closed = True
+return None
+@property
+def closed(self):
+return self._closed
+def tell(self):
+return self._bytes_decompressed
+def readall(self):
+chunks = []
+while True:
+chunk = self.read(1048576)
+if not chunk:
+break
+chunks.append(chunk)
+return b''.join(chunks)
+def __iter__(self):
+raise io.UnsupportedOperation()
+def __next__(self):
+raise io.UnsupportedOperation()
+next = __next__
+def _read_input(self):
+# We have data left over in the input buffer. Use it.
+if self._in_buffer.pos < self._in_buffer.size:
+return
+# All input data exhausted. Nothing to do.
+if self._finished_input:
+return
+# Else populate the input buffer from our source.
+if hasattr(self._source, 'read'):
+data = self._source.read(self._read_size)
+if not data:
+self._finished_input = True
+return
+self._source_buffer = ffi.from_buffer(data)
+self._in_buffer.src = self._source_buffer
+self._in_buffer.size = len(self._source_buffer)
+self._in_buffer.pos = 0
+else:
+self._source_buffer = ffi.from_buffer(self._source)
+self._in_buffer.src = self._source_buffer
+self._in_buffer.size = len(self._source_buffer)
+self._in_buffer.pos = 0
+def _decompress_into_buffer(self, out_buffer):
+"""Decompress available input into an output buffer.
+Returns True if data in output buffer should be emitted.
+"""
+zresult = lib.ZSTD_decompressStream(self._decompressor._dctx,
+out_buffer, self._in_buffer)
+if self._in_buffer.pos == self._in_buffer.size:
+self._in_buffer.src = ffi.NULL
+self._in_buffer.pos = 0
+self._in_buffer.size = 0
+self._source_buffer = None
+if not hasattr(self._source, 'read'):
+self._finished_input = True
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd decompress error: %s' %
+_zstd_error(zresult))
+# Emit data if there is data AND either:
+# a) output buffer is full (read amount is satisfied)
+# b) we're at end of a frame and not in frame spanning mode
+return (out_buffer.pos and
+(out_buffer.pos == out_buffer.size or
+zresult == 0 and not self._read_across_frames))
+def read(self, size=-1):
+if self._closed:
+raise ValueError('stream is closed')
+if size < -1:
+raise ValueError('cannot read negative amounts less than -1')
+if size == -1:
+# This is recursive. But it gets the job done.
+return self.readall()
+if self._finished_output or size == 0:
+return b''
+# We /could/ call into readinto() here. But that introduces more
+# overhead.
+dst_buffer = ffi.new('char[]', size)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dst_buffer
+out_buffer.size = size
+out_buffer.pos = 0
+self._read_input()
+if self._decompress_into_buffer(out_buffer):
+self._bytes_decompressed += out_buffer.pos
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+while not self._finished_input:
+self._read_input()
+if self._decompress_into_buffer(out_buffer):
+self._bytes_decompressed += out_buffer.pos
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+self._bytes_decompressed += out_buffer.pos
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+def readinto(self, b):
+if self._closed:
+raise ValueError('stream is closed')
+if self._finished_output:
+return 0
+# TODO use writable=True once we require CFFI >= 1.12.
+dest_buffer = ffi.from_buffer(b)
+ffi.memmove(b, b'', 0)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dest_buffer
+out_buffer.size = len(dest_buffer)
+out_buffer.pos = 0
+self._read_input()
+if self._decompress_into_buffer(out_buffer):
+self._bytes_decompressed += out_buffer.pos
+return out_buffer.pos
+while not self._finished_input:
+self._read_input()
+if self._decompress_into_buffer(out_buffer):
+self._bytes_decompressed += out_buffer.pos
+return out_buffer.pos
+self._bytes_decompressed += out_buffer.pos
+return out_buffer.pos
+def read1(self, size=-1):
+if self._closed:
+raise ValueError('stream is closed')
+if size < -1:
+raise ValueError('cannot read negative amounts less than -1')
+if self._finished_output or size == 0:
+return b''
+# -1 returns arbitrary number of bytes.
+if size == -1:
+size = DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
+dst_buffer = ffi.new('char[]', size)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dst_buffer
+out_buffer.size = size
+out_buffer.pos = 0
+# read1() dictates that we can perform at most 1 call to underlying
+# stream to get input. However, we can't satisfy this restriction with
+# decompression because not all input generates output. So we allow
+# multiple read(). But unlike read(), we stop once we have any output.
+while not self._finished_input:
+self._read_input()
+self._decompress_into_buffer(out_buffer)
+if out_buffer.pos:
+break
+self._bytes_decompressed += out_buffer.pos
+return ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+def readinto1(self, b):
+if self._closed:
+raise ValueError('stream is closed')
+if self._finished_output:
+return 0
+# TODO use writable=True once we require CFFI >= 1.12.
+dest_buffer = ffi.from_buffer(b)
+ffi.memmove(b, b'', 0)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = dest_buffer
+out_buffer.size = len(dest_buffer)
+out_buffer.pos = 0
+while not self._finished_input and not self._finished_output:
+self._read_input()
+self._decompress_into_buffer(out_buffer)
+if out_buffer.pos:
+break
+self._bytes_decompressed += out_buffer.pos
+return out_buffer.pos
+def seek(self, pos, whence=os.SEEK_SET):
+if self._closed:
+raise ValueError('stream is closed')
+read_amount = 0
+if whence == os.SEEK_SET:
+if pos < 0:
+raise ValueError('cannot seek to negative position with SEEK_SET')
+if pos < self._bytes_decompressed:
+raise ValueError('cannot seek zstd decompression stream '
+'backwards')
+read_amount = pos - self._bytes_decompressed
+elif whence == os.SEEK_CUR:
+if pos < 0:
+raise ValueError('cannot seek zstd decompression stream '
+'backwards')
+read_amount = pos
+elif whence == os.SEEK_END:
+raise ValueError('zstd decompression streams cannot be seeked '
+'with SEEK_END')
+while read_amount:
+result = self.read(min(read_amount,
+DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE))
+if not result:
+break
+read_amount -= len(result)
+return self._bytes_decompressed
+class ZstdDecompressionWriter(object):
+def __init__(self, decompressor, writer, write_size, write_return_read):
+decompressor._ensure_dctx()
+self._decompressor = decompressor
+self._writer = writer
+self._write_size = write_size
+self._write_return_read = bool(write_return_read)
+self._entered = False
+self._closed = False
+def __enter__(self):
+if self._closed:
+raise ValueError('stream is closed')
+if self._entered:
+raise ZstdError('cannot __enter__ multiple times')
+self._entered = True
+return self
+def __exit__(self, exc_type, exc_value, exc_tb):
+self._entered = False
+self.close()
+def memory_size(self):
+return lib.ZSTD_sizeof_DCtx(self._decompressor._dctx)
+def close(self):
+if self._closed:
+return
+try:
+self.flush()
+finally:
+self._closed = True
+f = getattr(self._writer, 'close', None)
+if f:
+f()
+@property
+def closed(self):
+return self._closed
+def fileno(self):
+f = getattr(self._writer, 'fileno', None)
+if f:
+return f()
+else:
+raise OSError('fileno not available on underlying writer')
+def flush(self):
+if self._closed:
+raise ValueError('stream is closed')
+f = getattr(self._writer, 'flush', None)
+if f:
+return f()
+def isatty(self):
+return False
+def readable(self):
+return False
+def readline(self, size=-1):
+raise io.UnsupportedOperation()
+def readlines(self, hint=-1):
+raise io.UnsupportedOperation()
+def seek(self, offset, whence=None):
+raise io.UnsupportedOperation()
+def seekable(self):
+return False
+def tell(self):
+raise io.UnsupportedOperation()
+def truncate(self, size=None):
+raise io.UnsupportedOperation()
+def writable(self):
+return True
+def writelines(self, lines):
+raise io.UnsupportedOperation()
+def read(self, size=-1):
+raise io.UnsupportedOperation()
+def readall(self):
+raise io.UnsupportedOperation()
+def readinto(self, b):
+raise io.UnsupportedOperation()
+def write(self, data):
+if self._closed:
+raise ValueError('stream is closed')
+total_write = 0
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+data_buffer = ffi.from_buffer(data)
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+dst_buffer = ffi.new('char[]', self._write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = len(dst_buffer)
+out_buffer.pos = 0
+dctx = self._decompressor._dctx
+while in_buffer.pos < in_buffer.size:
+zresult = lib.ZSTD_decompressStream(dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd decompress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+self._writer.write(ffi.buffer(out_buffer.dst, out_buffer.pos)[:])
+total_write += out_buffer.pos
+out_buffer.pos = 0
+if self._write_return_read:
+return in_buffer.pos
+else:
+return total_write
+class ZstdDecompressor(object):
+def __init__(self, dict_data=None, max_window_size=0, format=FORMAT_ZSTD1):
+self._dict_data = dict_data
+self._max_window_size = max_window_size
+self._format = format
+dctx = lib.ZSTD_createDCtx()
+if dctx == ffi.NULL:
+raise MemoryError()
+self._dctx = dctx
+# Defer setting up garbage collection until full state is loaded so
+# the memory size is more accurate.
+try:
+self._ensure_dctx()
+finally:
+self._dctx = ffi.gc(dctx, lib.ZSTD_freeDCtx,
+size=lib.ZSTD_sizeof_DCtx(dctx))
+def memory_size(self):
+return lib.ZSTD_sizeof_DCtx(self._dctx)
+def decompress(self, data, max_output_size=0):
+self._ensure_dctx()
+data_buffer = ffi.from_buffer(data)
+output_size = lib.ZSTD_getFrameContentSize(data_buffer, len(data_buffer))
+if output_size == lib.ZSTD_CONTENTSIZE_ERROR:
+raise ZstdError('error determining content size from frame header')
+elif output_size == 0:
+return b''
+elif output_size == lib.ZSTD_CONTENTSIZE_UNKNOWN:
+if not max_output_size:
+raise ZstdError('could not determine content size in frame header')
+result_buffer = ffi.new('char[]', max_output_size)
+result_size = max_output_size
+output_size = 0
+else:
+result_buffer = ffi.new('char[]', output_size)
+result_size = output_size
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = result_buffer
+out_buffer.size = result_size
+out_buffer.pos = 0
+in_buffer = ffi.new('ZSTD_inBuffer *')
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('decompression error: %s' %
+_zstd_error(zresult))
+elif zresult:
+raise ZstdError('decompression error: did not decompress full frame')
+elif output_size and out_buffer.pos != output_size:
+raise ZstdError('decompression error: decompressed %d bytes; expected %d' %
+(zresult, output_size))
+return ffi.buffer(result_buffer, out_buffer.pos)[:]
+def stream_reader(self, source, read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
+read_across_frames=False):
+self._ensure_dctx()
+return ZstdDecompressionReader(self, source, read_size, read_across_frames)
+def decompressobj(self, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE):
+if write_size < 1:
+raise ValueError('write_size must be positive')
+self._ensure_dctx()
+return ZstdDecompressionObj(self, write_size=write_size)
+def read_to_iter(self, reader, read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
+write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE,
+skip_bytes=0):
+if skip_bytes >= read_size:
+raise ValueError('skip_bytes must be smaller than read_size')
+if hasattr(reader, 'read'):
+have_read = True
+elif hasattr(reader, '__getitem__'):
+have_read = False
+buffer_offset = 0
+size = len(reader)
+else:
+raise ValueError('must pass an object with a read() method or '
+'conforms to buffer protocol')
+if skip_bytes:
+if have_read:
+reader.read(skip_bytes)
+else:
+if skip_bytes > size:
+raise ValueError('skip_bytes larger than first input chunk')
+buffer_offset = skip_bytes
+self._ensure_dctx()
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+dst_buffer = ffi.new('char[]', write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = len(dst_buffer)
+out_buffer.pos = 0
+while True:
+assert out_buffer.pos == 0
+if have_read:
+read_result = reader.read(read_size)
+else:
+remaining = size - buffer_offset
+slice_size = min(remaining, read_size)
+read_result = reader[buffer_offset:buffer_offset + slice_size]
+buffer_offset += slice_size
+# No new input. Break out of read loop.
+if not read_result:
+break
+# Feed all read data into decompressor and emit output until
+# exhausted.
+read_buffer = ffi.from_buffer(read_result)
+in_buffer.src = read_buffer
+in_buffer.size = len(read_buffer)
+in_buffer.pos = 0
+while in_buffer.pos < in_buffer.size:
+assert out_buffer.pos == 0
+zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd decompress error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:]
+out_buffer.pos = 0
+yield data
+if zresult == 0:
+return
+# Repeat loop to collect more input data.
+continue
+# If we get here, input is exhausted.
+read_from = read_to_iter
+def stream_writer(self, writer, write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE,
+write_return_read=False):
+if not hasattr(writer, 'write'):
+raise ValueError('must pass an object with a write() method')
+return ZstdDecompressionWriter(self, writer, write_size,
+write_return_read)
+write_to = stream_writer
+def copy_stream(self, ifh, ofh,
+read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
+write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE):
+if not hasattr(ifh, 'read'):
+raise ValueError('first argument must have a read() method')
+if not hasattr(ofh, 'write'):
+raise ValueError('second argument must have a write() method')
+self._ensure_dctx()
+in_buffer = ffi.new('ZSTD_inBuffer *')
+out_buffer = ffi.new('ZSTD_outBuffer *')
+dst_buffer = ffi.new('char[]', write_size)
+out_buffer.dst = dst_buffer
+out_buffer.size = write_size
+out_buffer.pos = 0
+total_read, total_write = 0, 0
+# Read all available input.
+while True:
+data = ifh.read(read_size)
+if not data:
+break
+data_buffer = ffi.from_buffer(data)
+total_read += len(data_buffer)
+in_buffer.src = data_buffer
+in_buffer.size = len(data_buffer)
+in_buffer.pos = 0
+# Flush all read data to output.
+while in_buffer.pos < in_buffer.size:
+zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('zstd decompressor error: %s' %
+_zstd_error(zresult))
+if out_buffer.pos:
+ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos))
+total_write += out_buffer.pos
+out_buffer.pos = 0
+# Continue loop to keep reading.
+return total_read, total_write
+def decompress_content_dict_chain(self, frames):
+if not isinstance(frames, list):
+raise TypeError('argument must be a list')
+if not frames:
+raise ValueError('empty input chain')
+# First chunk should not be using a dictionary. We handle it specially.
+chunk = frames[0]
+if not isinstance(chunk, bytes_type):
+raise ValueError('chunk 0 must be bytes')
+# All chunks should be zstd frames and should have content size set.
+chunk_buffer = ffi.from_buffer(chunk)
+params = ffi.new('ZSTD_frameHeader *')
+zresult = lib.ZSTD_getFrameHeader(params, chunk_buffer, len(chunk_buffer))
+if lib.ZSTD_isError(zresult):
+raise ValueError('chunk 0 is not a valid zstd frame')
+elif zresult:
+raise ValueError('chunk 0 is too small to contain a zstd frame')
+if params.frameContentSize == lib.ZSTD_CONTENTSIZE_UNKNOWN:
+raise ValueError('chunk 0 missing content size in frame')
+self._ensure_dctx(load_dict=False)
+last_buffer = ffi.new('char[]', params.frameContentSize)
+out_buffer = ffi.new('ZSTD_outBuffer *')
+out_buffer.dst = last_buffer
+out_buffer.size = len(last_buffer)
+out_buffer.pos = 0
+in_buffer = ffi.new('ZSTD_inBuffer *')
+in_buffer.src = chunk_buffer
+in_buffer.size = len(chunk_buffer)
+in_buffer.pos = 0
+zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('could not decompress chunk 0: %s' %
+_zstd_error(zresult))
+elif zresult:
+raise ZstdError('chunk 0 did not decompress full frame')
+# Special case of chain length of 1
+if len(frames) == 1:
+return ffi.buffer(last_buffer, len(last_buffer))[:]
+i = 1
+while i < len(frames):
+chunk = frames[i]
+if not isinstance(chunk, bytes_type):
+raise ValueError('chunk %d must be bytes' % i)
+chunk_buffer = ffi.from_buffer(chunk)
+zresult = lib.ZSTD_getFrameHeader(params, chunk_buffer, len(chunk_buffer))
+if lib.ZSTD_isError(zresult):
+raise ValueError('chunk %d is not a valid zstd frame' % i)
+elif zresult:
+raise ValueError('chunk %d is too small to contain a zstd frame' % i)
+if params.frameContentSize == lib.ZSTD_CONTENTSIZE_UNKNOWN:
+raise ValueError('chunk %d missing content size in frame' % i)
+dest_buffer = ffi.new('char[]', params.frameContentSize)
+out_buffer.dst = dest_buffer
+out_buffer.size = len(dest_buffer)
+out_buffer.pos = 0
+in_buffer.src = chunk_buffer
+in_buffer.size = len(chunk_buffer)
+in_buffer.pos = 0
+zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('could not decompress chunk %d: %s' %
+_zstd_error(zresult))
+elif zresult:
+raise ZstdError('chunk %d did not decompress full frame' % i)
+last_buffer = dest_buffer
+i += 1
+return ffi.buffer(last_buffer, len(last_buffer))[:]
+def _ensure_dctx(self, load_dict=True):
+lib.ZSTD_DCtx_reset(self._dctx, lib.ZSTD_reset_session_only)
+if self._max_window_size:
+zresult = lib.ZSTD_DCtx_setMaxWindowSize(self._dctx,
+self._max_window_size)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('unable to set max window size: %s' %
+_zstd_error(zresult))
+zresult = lib.ZSTD_DCtx_setFormat(self._dctx, self._format)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('unable to set decoding format: %s' %
+_zstd_error(zresult))
+if self._dict_data and load_dict:
+zresult = lib.ZSTD_DCtx_refDDict(self._dctx, self._dict_data._ddict)
+if lib.ZSTD_isError(zresult):
+raise ZstdError('unable to reference prepared dictionary: %s' %
+_zstd_error(zresult))

changeset 42070	675775c33ab6
parent 40121	73fef626dae3
child 42937	69de49c4e39c