python-zstandard: blacken at 80 characters

I made this change upstream and it will make it into the next
release of python-zstandard. I figured I'd send it Mercurial's
way because it will allow us to drop this directory from the black
exclusion list.

# skip-blame blackening

Differential Revision: https://phab.mercurial-scm.org/D7937

black.toml

@@ -1,15 +1,14 b''
 [tool.black]
 line-length = 80
 exclude = '''
 build/
 | wheelhouse/
 | dist/
 | packages/
 | \.hg/
 | \.mypy_cache/
 | \.venv/
 | mercurial/thirdparty/
-| contrib/python-zstandard/
 '''
 skip-string-normalization = true
 quiet = true

contrib/examples/fix.hgrc

@@ -1,14 +1,14 b''
 [fix]
 clang-format:command = clang-format --style file
 clang-format:pattern = set:(**.c or **.cc or **.h) and not "include:contrib/clang-format-ignorelist"
 
 rustfmt:command = rustfmt +nightly
 rustfmt:pattern = set:**.rs
 
 black:command = black --config=black.toml -
-black:pattern = set:**.py - mercurial/thirdparty/** - "contrib/python-zstandard/**"
+black:pattern = set:**.py - mercurial/thirdparty/**
 
 # Mercurial doesn't have any Go code, but if we did this is how we
 # would configure `hg fix` for Go:
 go:command = gofmt
 go:pattern = set:**.go

contrib/python-zstandard/make_cffi.py

@@ -1,225 +1,228 b''
 # 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.
 
 from __future__ import absolute_import
 
 import cffi
 import distutils.ccompiler
 import os
 import re
 import subprocess
 import tempfile
 
 
 HERE = os.path.abspath(os.path.dirname(__file__))
 
 SOURCES = [
     "zstd/%s" % p
     for p in (
         "common/debug.c",
         "common/entropy_common.c",
         "common/error_private.c",
         "common/fse_decompress.c",
         "common/pool.c",
         "common/threading.c",
         "common/xxhash.c",
         "common/zstd_common.c",
         "compress/fse_compress.c",
         "compress/hist.c",
         "compress/huf_compress.c",
         "compress/zstd_compress.c",
         "compress/zstd_compress_literals.c",
         "compress/zstd_compress_sequences.c",
         "compress/zstd_double_fast.c",
         "compress/zstd_fast.c",
         "compress/zstd_lazy.c",
         "compress/zstd_ldm.c",
         "compress/zstd_opt.c",
         "compress/zstdmt_compress.c",
         "decompress/huf_decompress.c",
         "decompress/zstd_ddict.c",
         "decompress/zstd_decompress.c",
         "decompress/zstd_decompress_block.c",
         "dictBuilder/cover.c",
         "dictBuilder/fastcover.c",
         "dictBuilder/divsufsort.c",
         "dictBuilder/zdict.c",
     )
 ]
 
 # Headers whose preprocessed output will be fed into cdef().
 HEADERS = [
-    os.path.join(HERE, "zstd", *p) for p in (("zstd.h",), ("dictBuilder", "zdict.h"),)
+    os.path.join(HERE, "zstd", *p)
+    for p in (("zstd.h",), ("dictBuilder", "zdict.h"),)
 ]
 
 INCLUDE_DIRS = [
     os.path.join(HERE, d)
     for d in (
         "zstd",
         "zstd/common",
         "zstd/compress",
         "zstd/decompress",
         "zstd/dictBuilder",
     )
 ]
 
 # cffi can't parse some of the primitives in zstd.h. So we invoke the
 # preprocessor and feed its output into cffi.
 compiler = distutils.ccompiler.new_compiler()
 
 # Needed for MSVC.
 if hasattr(compiler, "initialize"):
     compiler.initialize()
 
 # Distutils doesn't set compiler.preprocessor, so invoke the preprocessor
 # manually.
 if compiler.compiler_type == "unix":
     args = list(compiler.executables["compiler"])
     args.extend(
         ["-E", "-DZSTD_STATIC_LINKING_ONLY", "-DZDICT_STATIC_LINKING_ONLY",]
     )
 elif compiler.compiler_type == "msvc":
     args = [compiler.cc]
     args.extend(
         ["/EP", "/DZSTD_STATIC_LINKING_ONLY", "/DZDICT_STATIC_LINKING_ONLY",]
     )
 else:
     raise Exception("unsupported compiler type: %s" % compiler.compiler_type)
 
 
 def preprocess(path):
     with open(path, "rb") as fh:
         lines = []
         it = iter(fh)
 
         for l in it:
             # zstd.h includes <stddef.h>, which is also included by cffi's
             # boilerplate. This can lead to duplicate declarations. So we strip
             # this include from the preprocessor invocation.
             #
             # The same things happens for including zstd.h, so give it the same
             # treatment.
             #
             # We define ZSTD_STATIC_LINKING_ONLY, which is redundant with the inline
             # #define in zstdmt_compress.h and results in a compiler warning. So drop
             # the inline #define.
             if l.startswith(
                 (
                     b"#include <stddef.h>",
                     b'#include "zstd.h"',
                     b"#define ZSTD_STATIC_LINKING_ONLY",
                 )
             ):
                 continue
 
             # The preprocessor environment on Windows doesn't define include
             # paths, so the #include of limits.h fails. We work around this
             # by removing that import and defining INT_MAX ourselves. This is
             # a bit hacky. But it gets the job done.
             # TODO make limits.h work on Windows so we ensure INT_MAX is
             # correct.
             if l.startswith(b"#include <limits.h>"):
                 l = b"#define INT_MAX 2147483647\n"
 
             # ZSTDLIB_API may not be defined if we dropped zstd.h. It isn't
             # important so just filter it out.
             if l.startswith(b"ZSTDLIB_API"):
                 l = l[len(b"ZSTDLIB_API ") :]
 
             lines.append(l)
 
     fd, input_file = tempfile.mkstemp(suffix=".h")
     os.write(fd, b"".join(lines))
     os.close(fd)
 
     try:
         env = dict(os.environ)
         if getattr(compiler, "_paths", None):
             env["PATH"] = compiler._paths
-        process = subprocess.Popen(args + [input_file], stdout=subprocess.PIPE, env=env)
+        process = subprocess.Popen(
+            args + [input_file], stdout=subprocess.PIPE, env=env
+        )
         output = process.communicate()[0]
         ret = process.poll()
         if ret:
             raise Exception("preprocessor exited with error")
 
         return output
     finally:
         os.unlink(input_file)
 
 
 def normalize_output(output):
     lines = []
     for line in output.splitlines():
         # CFFI's parser doesn't like __attribute__ on UNIX compilers.
         if line.startswith(b'__attribute__ ((visibility ("default"))) '):
             line = line[len(b'__attribute__ ((visibility ("default"))) ') :]
 
         if line.startswith(b"__attribute__((deprecated("):
             continue
         elif b"__declspec(deprecated(" in line:
             continue
 
         lines.append(line)
 
     return b"\n".join(lines)
 
 
 ffi = cffi.FFI()
 # zstd.h uses a possible undefined MIN(). Define it until
 # https://github.com/facebook/zstd/issues/976 is fixed.
 # *_DISABLE_DEPRECATE_WARNINGS prevents the compiler from emitting a warning
 # when cffi uses the function. Since we statically link against zstd, even
 # if we use the deprecated functions it shouldn't be a huge problem.
 ffi.set_source(
     "_zstd_cffi",
     """
 #define MIN(a,b) ((a)<(b) ? (a) : (b))
 #define ZSTD_STATIC_LINKING_ONLY
 #include <zstd.h>
 #define ZDICT_STATIC_LINKING_ONLY
 #define ZDICT_DISABLE_DEPRECATE_WARNINGS
 #include <zdict.h>
 """,
     sources=SOURCES,
     include_dirs=INCLUDE_DIRS,
     extra_compile_args=["-DZSTD_MULTITHREAD"],
 )
 
 DEFINE = re.compile(b"^\\#define ([a-zA-Z0-9_]+) ")
 
 sources = []
 
 # Feed normalized preprocessor output for headers into the cdef parser.
 for header in HEADERS:
     preprocessed = preprocess(header)
     sources.append(normalize_output(preprocessed))
 
     # #define's are effectively erased as part of going through preprocessor.
     # So perform a manual pass to re-add those to the cdef source.
     with open(header, "rb") as fh:
         for line in fh:
             line = line.strip()
             m = DEFINE.match(line)
             if not m:
                 continue
 
             if m.group(1) == b"ZSTD_STATIC_LINKING_ONLY":
                 continue
 
             # The parser doesn't like some constants with complex values.
             if m.group(1) in (b"ZSTD_LIB_VERSION", b"ZSTD_VERSION_STRING"):
                 continue
 
             # The ... is magic syntax by the cdef parser to resolve the
             # value at compile time.
             sources.append(m.group(0) + b" ...")
 
 cdeflines = b"\n".join(sources).splitlines()
 cdeflines = [l for l in cdeflines if l.strip()]
 ffi.cdef(b"\n".join(cdeflines).decode("latin1"))
 
 if __name__ == "__main__":
     ffi.compile()

contrib/python-zstandard/setup.py

@@ -1,118 +1,120 b''
 #!/usr/bin/env python
 # 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.
 
 from __future__ import print_function
 
 from distutils.version import LooseVersion
 import os
 import sys
 from setuptools import setup
 
 # Need change in 1.10 for ffi.from_buffer() to handle all buffer types
 # (like memoryview).
 # Need feature in 1.11 for ffi.gc() to declare size of objects so we avoid
 # garbage collection pitfalls.
 MINIMUM_CFFI_VERSION = "1.11"
 
 try:
     import cffi
 
     # PyPy (and possibly other distros) have CFFI distributed as part of
     # them. The install_requires for CFFI below won't work. We need to sniff
     # out the CFFI version here and reject CFFI if it is too old.
     cffi_version = LooseVersion(cffi.__version__)
     if cffi_version < LooseVersion(MINIMUM_CFFI_VERSION):
         print(
             "CFFI 1.11 or newer required (%s found); "
             "not building CFFI backend" % cffi_version,
             file=sys.stderr,
         )
         cffi = None
 
 except ImportError:
     cffi = None
 
 import setup_zstd
 
 SUPPORT_LEGACY = False
 SYSTEM_ZSTD = False
 WARNINGS_AS_ERRORS = False
 
 if os.environ.get("ZSTD_WARNINGS_AS_ERRORS", ""):
     WARNINGS_AS_ERRORS = True
 
 if "--legacy" in sys.argv:
     SUPPORT_LEGACY = True
     sys.argv.remove("--legacy")
 
 if "--system-zstd" in sys.argv:
     SYSTEM_ZSTD = True
     sys.argv.remove("--system-zstd")
 
 if "--warnings-as-errors" in sys.argv:
     WARNINGS_AS_ERRORS = True
     sys.argv.remove("--warning-as-errors")
 
 # Code for obtaining the Extension instance is in its own module to
 # facilitate reuse in other projects.
 extensions = [
     setup_zstd.get_c_extension(
         name="zstd",
         support_legacy=SUPPORT_LEGACY,
         system_zstd=SYSTEM_ZSTD,
         warnings_as_errors=WARNINGS_AS_ERRORS,
     ),
 ]
 
 install_requires = []
 
 if cffi:
     import make_cffi
 
     extensions.append(make_cffi.ffi.distutils_extension())
     install_requires.append("cffi>=%s" % MINIMUM_CFFI_VERSION)
 
 version = None
 
 with open("c-ext/python-zstandard.h", "r") as fh:
     for line in fh:
         if not line.startswith("#define PYTHON_ZSTANDARD_VERSION"):
             continue
 
         version = line.split()[2][1:-1]
         break
 
 if not version:
-    raise Exception("could not resolve package version; " "this should never happen")
+    raise Exception(
+        "could not resolve package version; " "this should never happen"
+    )
 
 setup(
     name="zstandard",
     version=version,
     description="Zstandard bindings for Python",
     long_description=open("README.rst", "r").read(),
     url="https://github.com/indygreg/python-zstandard",
     author="Gregory Szorc",
     author_email="[e-mail]",
     license="BSD",
     classifiers=[
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: BSD License",
         "Programming Language :: C",
         "Programming Language :: Python :: 2.7",
         "Programming Language :: Python :: 3.5",
         "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
     ],
     keywords="zstandard zstd compression",
     packages=["zstandard"],
     ext_modules=extensions,
     test_suite="tests",
     install_requires=install_requires,
     tests_require=["hypothesis"],
 )

contrib/python-zstandard/setup_zstd.py

@@ -1,206 +1,210 b''
 # 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.
 
 import distutils.ccompiler
 import os
 
 from distutils.extension import Extension
 
 
 zstd_sources = [
     "zstd/%s" % p
     for p in (
         "common/debug.c",
         "common/entropy_common.c",
         "common/error_private.c",
         "common/fse_decompress.c",
         "common/pool.c",
         "common/threading.c",
         "common/xxhash.c",
         "common/zstd_common.c",
         "compress/fse_compress.c",
         "compress/hist.c",
         "compress/huf_compress.c",
         "compress/zstd_compress_literals.c",
         "compress/zstd_compress_sequences.c",
         "compress/zstd_compress.c",
         "compress/zstd_double_fast.c",
         "compress/zstd_fast.c",
         "compress/zstd_lazy.c",
         "compress/zstd_ldm.c",
         "compress/zstd_opt.c",
         "compress/zstdmt_compress.c",
         "decompress/huf_decompress.c",
         "decompress/zstd_ddict.c",
         "decompress/zstd_decompress.c",
         "decompress/zstd_decompress_block.c",
         "dictBuilder/cover.c",
         "dictBuilder/divsufsort.c",
         "dictBuilder/fastcover.c",
         "dictBuilder/zdict.c",
     )
 ]
 
 zstd_sources_legacy = [
     "zstd/%s" % p
     for p in (
         "deprecated/zbuff_common.c",
         "deprecated/zbuff_compress.c",
         "deprecated/zbuff_decompress.c",
         "legacy/zstd_v01.c",
         "legacy/zstd_v02.c",
         "legacy/zstd_v03.c",
         "legacy/zstd_v04.c",
         "legacy/zstd_v05.c",
         "legacy/zstd_v06.c",
         "legacy/zstd_v07.c",
     )
 ]
 
 zstd_includes = [
     "zstd",
     "zstd/common",
     "zstd/compress",
     "zstd/decompress",
     "zstd/dictBuilder",
 ]
 
 zstd_includes_legacy = [
     "zstd/deprecated",
     "zstd/legacy",
 ]
 
 ext_includes = [
     "c-ext",
     "zstd/common",
 ]
 
 ext_sources = [
     "zstd/common/error_private.c",
     "zstd/common/pool.c",
     "zstd/common/threading.c",
     "zstd/common/zstd_common.c",
     "zstd.c",
     "c-ext/bufferutil.c",
     "c-ext/compressiondict.c",
     "c-ext/compressobj.c",
     "c-ext/compressor.c",
     "c-ext/compressoriterator.c",
     "c-ext/compressionchunker.c",
     "c-ext/compressionparams.c",
     "c-ext/compressionreader.c",
     "c-ext/compressionwriter.c",
     "c-ext/constants.c",
     "c-ext/decompressobj.c",
     "c-ext/decompressor.c",
     "c-ext/decompressoriterator.c",
     "c-ext/decompressionreader.c",
     "c-ext/decompressionwriter.c",
     "c-ext/frameparams.c",
 ]
 
 zstd_depends = [
     "c-ext/python-zstandard.h",
 ]
 
 
 def get_c_extension(
     support_legacy=False,
     system_zstd=False,
     name="zstd",
     warnings_as_errors=False,
     root=None,
 ):
     """Obtain a distutils.extension.Extension for the C extension.
 
     ``support_legacy`` controls whether to compile in legacy zstd format support.
 
     ``system_zstd`` controls whether to compile against the system zstd library.
     For this to work, the system zstd library and headers must match what
     python-zstandard is coded against exactly.
 
     ``name`` is the module name of the C extension to produce.
 
     ``warnings_as_errors`` controls whether compiler warnings are turned into
     compiler errors.
 
     ``root`` defines a root path that source should be computed as relative
     to. This should be the directory with the main ``setup.py`` that is
     being invoked. If not defined, paths will be relative to this file.
     """
     actual_root = os.path.abspath(os.path.dirname(__file__))
     root = root or actual_root
 
     sources = set([os.path.join(actual_root, p) for p in ext_sources])
     if not system_zstd:
         sources.update([os.path.join(actual_root, p) for p in zstd_sources])
         if support_legacy:
-            sources.update([os.path.join(actual_root, p) for p in zstd_sources_legacy])
+            sources.update(
+                [os.path.join(actual_root, p) for p in zstd_sources_legacy]
+            )
     sources = list(sources)
 
     include_dirs = set([os.path.join(actual_root, d) for d in ext_includes])
     if not system_zstd:
-        include_dirs.update([os.path.join(actual_root, d) for d in zstd_includes])
+        include_dirs.update(
+            [os.path.join(actual_root, d) for d in zstd_includes]
+        )
         if support_legacy:
             include_dirs.update(
                 [os.path.join(actual_root, d) for d in zstd_includes_legacy]
             )
     include_dirs = list(include_dirs)
 
     depends = [os.path.join(actual_root, p) for p in zstd_depends]
 
     compiler = distutils.ccompiler.new_compiler()
 
     # Needed for MSVC.
     if hasattr(compiler, "initialize"):
         compiler.initialize()
 
     if compiler.compiler_type == "unix":
         compiler_type = "unix"
     elif compiler.compiler_type == "msvc":
         compiler_type = "msvc"
     elif compiler.compiler_type == "mingw32":
         compiler_type = "mingw32"
     else:
         raise Exception("unhandled compiler type: %s" % compiler.compiler_type)
 
     extra_args = ["-DZSTD_MULTITHREAD"]
 
     if not system_zstd:
         extra_args.append("-DZSTDLIB_VISIBILITY=")
         extra_args.append("-DZDICTLIB_VISIBILITY=")
         extra_args.append("-DZSTDERRORLIB_VISIBILITY=")
 
         if compiler_type == "unix":
             extra_args.append("-fvisibility=hidden")
 
     if not system_zstd and support_legacy:
         extra_args.append("-DZSTD_LEGACY_SUPPORT=1")
 
     if warnings_as_errors:
         if compiler_type in ("unix", "mingw32"):
             extra_args.append("-Werror")
         elif compiler_type == "msvc":
             extra_args.append("/WX")
         else:
             assert False
 
     libraries = ["zstd"] if system_zstd else []
 
     # Python 3.7 doesn't like absolute paths. So normalize to relative.
     sources = [os.path.relpath(p, root) for p in sources]
     include_dirs = [os.path.relpath(p, root) for p in include_dirs]
     depends = [os.path.relpath(p, root) for p in depends]
 
     # TODO compile with optimizations.
     return Extension(
         name,
         sources,
         include_dirs=include_dirs,
         depends=depends,
         extra_compile_args=extra_args,
         libraries=libraries,
     )

contrib/python-zstandard/tests/common.py

@@ -1,197 +1,203 b''
 import imp
 import inspect
 import io
 import os
 import types
 import unittest
 
 try:
     import hypothesis
 except ImportError:
     hypothesis = None
 
 
 class TestCase(unittest.TestCase):
     if not getattr(unittest.TestCase, "assertRaisesRegex", False):
         assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
 
 
 def make_cffi(cls):
     """Decorator to add CFFI versions of each test method."""
 
     # The module containing this class definition should
     # `import zstandard as zstd`. Otherwise things may blow up.
     mod = inspect.getmodule(cls)
     if not hasattr(mod, "zstd"):
         raise Exception('test module does not contain "zstd" symbol')
 
     if not hasattr(mod.zstd, "backend"):
         raise Exception(
             'zstd symbol does not have "backend" attribute; did '
             "you `import zstandard as zstd`?"
         )
 
     # If `import zstandard` already chose the cffi backend, there is nothing
     # for us to do: we only add the cffi variation if the default backend
     # is the C extension.
     if mod.zstd.backend == "cffi":
         return cls
 
     old_env = dict(os.environ)
     os.environ["PYTHON_ZSTANDARD_IMPORT_POLICY"] = "cffi"
     try:
         try:
             mod_info = imp.find_module("zstandard")
             mod = imp.load_module("zstandard_cffi", *mod_info)
         except ImportError:
             return cls
     finally:
         os.environ.clear()
         os.environ.update(old_env)
 
     if mod.backend != "cffi":
-        raise Exception("got the zstandard %s backend instead of cffi" % mod.backend)
+        raise Exception(
+            "got the zstandard %s backend instead of cffi" % mod.backend
+        )
 
     # If CFFI version is available, dynamically construct test methods
     # that use it.
 
     for attr in dir(cls):
         fn = getattr(cls, attr)
         if not inspect.ismethod(fn) and not inspect.isfunction(fn):
             continue
 
         if not fn.__name__.startswith("test_"):
             continue
 
         name = "%s_cffi" % fn.__name__
 
         # Replace the "zstd" symbol with the CFFI module instance. Then copy
         # the function object and install it in a new attribute.
         if isinstance(fn, types.FunctionType):
             globs = dict(fn.__globals__)
             globs["zstd"] = mod
             new_fn = types.FunctionType(
                 fn.__code__, globs, name, fn.__defaults__, fn.__closure__
             )
             new_method = new_fn
         else:
             globs = dict(fn.__func__.func_globals)
             globs["zstd"] = mod
             new_fn = types.FunctionType(
                 fn.__func__.func_code,
                 globs,
                 name,
                 fn.__func__.func_defaults,
                 fn.__func__.func_closure,
             )
-            new_method = types.UnboundMethodType(new_fn, fn.im_self, fn.im_class)
+            new_method = types.UnboundMethodType(
+                new_fn, fn.im_self, fn.im_class
+            )
 
         setattr(cls, name, new_method)
 
     return cls
 
 
 class NonClosingBytesIO(io.BytesIO):
     """BytesIO that saves the underlying buffer on close().
 
     This allows us to access written data after close().
     """
 
     def __init__(self, *args, **kwargs):
         super(NonClosingBytesIO, self).__init__(*args, **kwargs)
         self._saved_buffer = None
 
     def close(self):
         self._saved_buffer = self.getvalue()
         return super(NonClosingBytesIO, self).close()
 
     def getvalue(self):
         if self.closed:
             return self._saved_buffer
         else:
             return super(NonClosingBytesIO, self).getvalue()
 
 
 class OpCountingBytesIO(NonClosingBytesIO):
     def __init__(self, *args, **kwargs):
         self._flush_count = 0
         self._read_count = 0
         self._write_count = 0
         return super(OpCountingBytesIO, self).__init__(*args, **kwargs)
 
     def flush(self):
         self._flush_count += 1
         return super(OpCountingBytesIO, self).flush()
 
     def read(self, *args):
         self._read_count += 1
         return super(OpCountingBytesIO, self).read(*args)
 
     def write(self, data):
         self._write_count += 1
         return super(OpCountingBytesIO, self).write(data)
 
 
 _source_files = []
 
 
 def random_input_data():
     """Obtain the raw content of source files.
 
     This is used for generating "random" data to feed into fuzzing, since it is
     faster than random content generation.
     """
     if _source_files:
         return _source_files
 
     for root, dirs, files in os.walk(os.path.dirname(__file__)):
         dirs[:] = list(sorted(dirs))
         for f in sorted(files):
             try:
                 with open(os.path.join(root, f), "rb") as fh:
                     data = fh.read()
                     if data:
                         _source_files.append(data)
             except OSError:
                 pass
 
     # Also add some actual random data.
     _source_files.append(os.urandom(100))
     _source_files.append(os.urandom(1000))
     _source_files.append(os.urandom(10000))
     _source_files.append(os.urandom(100000))
     _source_files.append(os.urandom(1000000))
 
     return _source_files
 
 
 def generate_samples():
     inputs = [
         b"foo",
         b"bar",
         b"abcdef",
         b"sometext",
         b"baz",
     ]
 
     samples = []
 
     for i in range(128):
         samples.append(inputs[i % 5])
         samples.append(inputs[i % 5] * (i + 3))
         samples.append(inputs[-(i % 5)] * (i + 2))
 
     return samples
 
 
 if hypothesis:
     default_settings = hypothesis.settings(deadline=10000)
     hypothesis.settings.register_profile("default", default_settings)
 
     ci_settings = hypothesis.settings(deadline=20000, max_examples=1000)
     hypothesis.settings.register_profile("ci", ci_settings)
 
     expensive_settings = hypothesis.settings(deadline=None, max_examples=10000)
     hypothesis.settings.register_profile("expensive", expensive_settings)
 
-    hypothesis.settings.load_profile(os.environ.get("HYPOTHESIS_PROFILE", "default"))
+    hypothesis.settings.load_profile(
+        os.environ.get("HYPOTHESIS_PROFILE", "default")
+    )

contrib/python-zstandard/tests/test_buffer_util.py

@@ -1,146 +1,153 b''
 import struct
 import unittest
 
 import zstandard as zstd
 
 from .common import TestCase
 
 ss = struct.Struct("=QQ")
 
 
 class TestBufferWithSegments(TestCase):
     def test_arguments(self):
         if not hasattr(zstd, "BufferWithSegments"):
             self.skipTest("BufferWithSegments not available")
 
         with self.assertRaises(TypeError):
             zstd.BufferWithSegments()
 
         with self.assertRaises(TypeError):
             zstd.BufferWithSegments(b"foo")
 
         # Segments data should be a multiple of 16.
         with self.assertRaisesRegex(
             ValueError, "segments array size is not a multiple of 16"
         ):
             zstd.BufferWithSegments(b"foo", b"\x00\x00")
 
     def test_invalid_offset(self):
         if not hasattr(zstd, "BufferWithSegments"):
             self.skipTest("BufferWithSegments not available")
 
         with self.assertRaisesRegex(
             ValueError, "offset within segments array references memory"
         ):
             zstd.BufferWithSegments(b"foo", ss.pack(0, 4))
 
     def test_invalid_getitem(self):
         if not hasattr(zstd, "BufferWithSegments"):
             self.skipTest("BufferWithSegments not available")
 
         b = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
 
         with self.assertRaisesRegex(IndexError, "offset must be non-negative"):
             test = b[-10]
 
         with self.assertRaisesRegex(IndexError, "offset must be less than 1"):
             test = b[1]
 
         with self.assertRaisesRegex(IndexError, "offset must be less than 1"):
             test = b[2]
 
     def test_single(self):
         if not hasattr(zstd, "BufferWithSegments"):
             self.skipTest("BufferWithSegments not available")
 
         b = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
         self.assertEqual(len(b), 1)
         self.assertEqual(b.size, 3)
         self.assertEqual(b.tobytes(), b"foo")
 
         self.assertEqual(len(b[0]), 3)
         self.assertEqual(b[0].offset, 0)
         self.assertEqual(b[0].tobytes(), b"foo")
 
     def test_multiple(self):
         if not hasattr(zstd, "BufferWithSegments"):
             self.skipTest("BufferWithSegments not available")
 
         b = zstd.BufferWithSegments(
-            b"foofooxfooxy", b"".join([ss.pack(0, 3), ss.pack(3, 4), ss.pack(7, 5)])
+            b"foofooxfooxy",
+            b"".join([ss.pack(0, 3), ss.pack(3, 4), ss.pack(7, 5)]),
         )
         self.assertEqual(len(b), 3)
         self.assertEqual(b.size, 12)
         self.assertEqual(b.tobytes(), b"foofooxfooxy")
 
         self.assertEqual(b[0].tobytes(), b"foo")
         self.assertEqual(b[1].tobytes(), b"foox")
         self.assertEqual(b[2].tobytes(), b"fooxy")
 
 
 class TestBufferWithSegmentsCollection(TestCase):
     def test_empty_constructor(self):
         if not hasattr(zstd, "BufferWithSegmentsCollection"):
             self.skipTest("BufferWithSegmentsCollection not available")
 
-        with self.assertRaisesRegex(ValueError, "must pass at least 1 argument"):
+        with self.assertRaisesRegex(
+            ValueError, "must pass at least 1 argument"
+        ):
             zstd.BufferWithSegmentsCollection()
 
     def test_argument_validation(self):
         if not hasattr(zstd, "BufferWithSegmentsCollection"):
             self.skipTest("BufferWithSegmentsCollection not available")
 
-        with self.assertRaisesRegex(TypeError, "arguments must be BufferWithSegments"):
+        with self.assertRaisesRegex(
+            TypeError, "arguments must be BufferWithSegments"
+        ):
             zstd.BufferWithSegmentsCollection(None)
 
-        with self.assertRaisesRegex(TypeError, "arguments must be BufferWithSegments"):
+        with self.assertRaisesRegex(
+            TypeError, "arguments must be BufferWithSegments"
+        ):
             zstd.BufferWithSegmentsCollection(
                 zstd.BufferWithSegments(b"foo", ss.pack(0, 3)), None
             )
 
         with self.assertRaisesRegex(
             ValueError, "ZstdBufferWithSegments cannot be empty"
         ):
             zstd.BufferWithSegmentsCollection(zstd.BufferWithSegments(b"", b""))
 
     def test_length(self):
         if not hasattr(zstd, "BufferWithSegmentsCollection"):
             self.skipTest("BufferWithSegmentsCollection not available")
 
         b1 = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
         b2 = zstd.BufferWithSegments(
             b"barbaz", b"".join([ss.pack(0, 3), ss.pack(3, 3)])
         )
 
         c = zstd.BufferWithSegmentsCollection(b1)
         self.assertEqual(len(c), 1)
         self.assertEqual(c.size(), 3)
 
         c = zstd.BufferWithSegmentsCollection(b2)
         self.assertEqual(len(c), 2)
         self.assertEqual(c.size(), 6)
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
         self.assertEqual(len(c), 3)
         self.assertEqual(c.size(), 9)
 
     def test_getitem(self):
         if not hasattr(zstd, "BufferWithSegmentsCollection"):
             self.skipTest("BufferWithSegmentsCollection not available")
 
         b1 = zstd.BufferWithSegments(b"foo", ss.pack(0, 3))
         b2 = zstd.BufferWithSegments(
             b"barbaz", b"".join([ss.pack(0, 3), ss.pack(3, 3)])
         )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
         with self.assertRaisesRegex(IndexError, "offset must be less than 3"):
             c[3]
 
         with self.assertRaisesRegex(IndexError, "offset must be less than 3"):
             c[4]
 
         self.assertEqual(c[0].tobytes(), b"foo")
         self.assertEqual(c[1].tobytes(), b"bar")
         self.assertEqual(c[2].tobytes(), b"baz")

contrib/python-zstandard/tests/test_compressor.py

@@ -1,1770 +1,1803 b''
 import hashlib
 import io
 import os
 import struct
 import sys
 import tarfile
 import tempfile
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     NonClosingBytesIO,
     OpCountingBytesIO,
     TestCase,
 )
 
 
 if sys.version_info[0] >= 3:
     next = lambda it: it.__next__()
 else:
     next = lambda it: it.next()
 
 
 def multithreaded_chunk_size(level, source_size=0):
-    params = zstd.ZstdCompressionParameters.from_level(level, source_size=source_size)
+    params = zstd.ZstdCompressionParameters.from_level(
+        level, source_size=source_size
+    )
 
     return 1 << (params.window_log + 2)
 
 
 @make_cffi
 class TestCompressor(TestCase):
     def test_level_bounds(self):
         with self.assertRaises(ValueError):
             zstd.ZstdCompressor(level=23)
 
     def test_memory_size(self):
         cctx = zstd.ZstdCompressor(level=1)
         self.assertGreater(cctx.memory_size(), 100)
 
 
 @make_cffi
 class TestCompressor_compress(TestCase):
     def test_compress_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         result = cctx.compress(b"")
         self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum, 0)
 
         cctx = zstd.ZstdCompressor()
         result = cctx.compress(b"")
         self.assertEqual(result, b"\x28\xb5\x2f\xfd\x20\x00\x01\x00\x00")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, 0)
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         expected = b"\x28\xb5\x2f\xfd\x00\x00\x19\x00\x00\x66\x6f\x6f"
 
         mutable_array = bytearray(3)
         mutable_array[:] = b"foo"
 
         sources = [
             memoryview(b"foo"),
             bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             self.assertEqual(cctx.compress(source), expected)
 
     def test_compress_large(self):
         chunks = []
         for i in range(255):
             chunks.append(struct.Struct(">B").pack(i) * 16384)
 
         cctx = zstd.ZstdCompressor(level=3, write_content_size=False)
         result = cctx.compress(b"".join(chunks))
         self.assertEqual(len(result), 999)
         self.assertEqual(result[0:4], b"\x28\xb5\x2f\xfd")
 
         # This matches the test for read_to_iter() below.
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
-        result = cctx.compress(b"f" * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE + b"o")
+        result = cctx.compress(
+            b"f" * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE + b"o"
+        )
         self.assertEqual(
             result,
             b"\x28\xb5\x2f\xfd\x00\x40\x54\x00\x00"
             b"\x10\x66\x66\x01\x00\xfb\xff\x39\xc0"
             b"\x02\x09\x00\x00\x6f",
         )
 
     def test_negative_level(self):
         cctx = zstd.ZstdCompressor(level=-4)
         result = cctx.compress(b"foo" * 256)
 
     def test_no_magic(self):
-        params = zstd.ZstdCompressionParameters.from_level(1, format=zstd.FORMAT_ZSTD1)
+        params = zstd.ZstdCompressionParameters.from_level(
+            1, format=zstd.FORMAT_ZSTD1
+        )
         cctx = zstd.ZstdCompressor(compression_params=params)
         magic = cctx.compress(b"foobar")
 
         params = zstd.ZstdCompressionParameters.from_level(
             1, format=zstd.FORMAT_ZSTD1_MAGICLESS
         )
         cctx = zstd.ZstdCompressor(compression_params=params)
         no_magic = cctx.compress(b"foobar")
 
         self.assertEqual(magic[0:4], b"\x28\xb5\x2f\xfd")
         self.assertEqual(magic[4:], no_magic)
 
     def test_write_checksum(self):
         cctx = zstd.ZstdCompressor(level=1)
         no_checksum = cctx.compress(b"foobar")
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         with_checksum = cctx.compress(b"foobar")
 
         self.assertEqual(len(with_checksum), len(no_checksum) + 4)
 
         no_params = zstd.get_frame_parameters(no_checksum)
         with_params = zstd.get_frame_parameters(with_checksum)
 
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
     def test_write_content_size(self):
         cctx = zstd.ZstdCompressor(level=1)
         with_size = cctx.compress(b"foobar" * 256)
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         no_size = cctx.compress(b"foobar" * 256)
 
         self.assertEqual(len(with_size), len(no_size) + 1)
 
         no_params = zstd.get_frame_parameters(no_size)
         with_params = zstd.get_frame_parameters(with_size)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
 
     def test_no_dict_id(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         with_dict_id = cctx.compress(b"foobarfoobar")
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False)
         no_dict_id = cctx.compress(b"foobarfoobar")
 
         self.assertEqual(len(with_dict_id), len(no_dict_id) + 4)
 
         no_params = zstd.get_frame_parameters(no_dict_id)
         with_params = zstd.get_frame_parameters(with_dict_id)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 1880053135)
 
     def test_compress_dict_multiple(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
 
         for i in range(32):
             cctx.compress(b"foo bar foobar foo bar foobar")
 
     def test_dict_precompute(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
         d.precompute_compress(level=1)
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
 
         for i in range(32):
             cctx.compress(b"foo bar foobar foo bar foobar")
 
     def test_multithreaded(self):
         chunk_size = multithreaded_chunk_size(1)
         source = b"".join([b"x" * chunk_size, b"y" * chunk_size])
 
         cctx = zstd.ZstdCompressor(level=1, threads=2)
         compressed = cctx.compress(source)
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, chunk_size * 2)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         dctx = zstd.ZstdDecompressor()
         self.assertEqual(dctx.decompress(compressed), source)
 
     def test_multithreaded_dict(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         cctx = zstd.ZstdCompressor(dict_data=d, threads=2)
 
         result = cctx.compress(b"foo")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, 3)
         self.assertEqual(params.dict_id, d.dict_id())
 
         self.assertEqual(
             result,
-            b"\x28\xb5\x2f\xfd\x23\x8f\x55\x0f\x70\x03\x19\x00\x00" b"\x66\x6f\x6f",
+            b"\x28\xb5\x2f\xfd\x23\x8f\x55\x0f\x70\x03\x19\x00\x00"
+            b"\x66\x6f\x6f",
         )
 
     def test_multithreaded_compression_params(self):
         params = zstd.ZstdCompressionParameters.from_level(0, threads=2)
         cctx = zstd.ZstdCompressor(compression_params=params)
 
         result = cctx.compress(b"foo")
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, 3)
 
-        self.assertEqual(result, b"\x28\xb5\x2f\xfd\x20\x03\x19\x00\x00\x66\x6f\x6f")
+        self.assertEqual(
+            result, b"\x28\xb5\x2f\xfd\x20\x03\x19\x00\x00\x66\x6f\x6f"
+        )
 
 
 @make_cffi
 class TestCompressor_compressobj(TestCase):
     def test_compressobj_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         cobj = cctx.compressobj()
         self.assertEqual(cobj.compress(b""), b"")
         self.assertEqual(cobj.flush(), b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
     def test_input_types(self):
         expected = b"\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f"
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         mutable_array = bytearray(3)
         mutable_array[:] = b"foo"
 
         sources = [
             memoryview(b"foo"),
             bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             cobj = cctx.compressobj()
             self.assertEqual(cobj.compress(source), b"")
             self.assertEqual(cobj.flush(), expected)
 
     def test_compressobj_large(self):
         chunks = []
         for i in range(255):
             chunks.append(struct.Struct(">B").pack(i) * 16384)
 
         cctx = zstd.ZstdCompressor(level=3)
         cobj = cctx.compressobj()
 
         result = cobj.compress(b"".join(chunks)) + cobj.flush()
         self.assertEqual(len(result), 999)
         self.assertEqual(result[0:4], b"\x28\xb5\x2f\xfd")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
     def test_write_checksum(self):
         cctx = zstd.ZstdCompressor(level=1)
         cobj = cctx.compressobj()
         no_checksum = cobj.compress(b"foobar") + cobj.flush()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         cobj = cctx.compressobj()
         with_checksum = cobj.compress(b"foobar") + cobj.flush()
 
         no_params = zstd.get_frame_parameters(no_checksum)
         with_params = zstd.get_frame_parameters(with_checksum)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
         self.assertEqual(len(with_checksum), len(no_checksum) + 4)
 
     def test_write_content_size(self):
         cctx = zstd.ZstdCompressor(level=1)
         cobj = cctx.compressobj(size=len(b"foobar" * 256))
         with_size = cobj.compress(b"foobar" * 256) + cobj.flush()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         cobj = cctx.compressobj(size=len(b"foobar" * 256))
         no_size = cobj.compress(b"foobar" * 256) + cobj.flush()
 
         no_params = zstd.get_frame_parameters(no_size)
         with_params = zstd.get_frame_parameters(with_size)
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
         self.assertEqual(len(with_size), len(no_size) + 1)
 
     def test_compress_after_finished(self):
         cctx = zstd.ZstdCompressor()
         cobj = cctx.compressobj()
 
         cobj.compress(b"foo")
         cobj.flush()
 
         with self.assertRaisesRegex(
             zstd.ZstdError, r"cannot call compress\(\) after compressor"
         ):
             cobj.compress(b"foo")
 
         with self.assertRaisesRegex(
             zstd.ZstdError, "compressor object already finished"
         ):
             cobj.flush()
 
     def test_flush_block_repeated(self):
         cctx = zstd.ZstdCompressor(level=1)
         cobj = cctx.compressobj()
 
         self.assertEqual(cobj.compress(b"foo"), b"")
         self.assertEqual(
             cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK),
             b"\x28\xb5\x2f\xfd\x00\x48\x18\x00\x00foo",
         )
         self.assertEqual(cobj.compress(b"bar"), b"")
         # 3 byte header plus content.
-        self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b"\x18\x00\x00bar")
+        self.assertEqual(
+            cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b"\x18\x00\x00bar"
+        )
         self.assertEqual(cobj.flush(), b"\x01\x00\x00")
 
     def test_flush_empty_block(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
         cobj = cctx.compressobj()
 
         cobj.compress(b"foobar")
         cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK)
         # No-op if no block is active (this is internal to zstd).
         self.assertEqual(cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK), b"")
 
         trailing = cobj.flush()
         # 3 bytes block header + 4 bytes frame checksum
         self.assertEqual(len(trailing), 7)
         header = trailing[0:3]
         self.assertEqual(header, b"\x01\x00\x00")
 
     def test_multithreaded(self):
         source = io.BytesIO()
         source.write(b"a" * 1048576)
         source.write(b"b" * 1048576)
         source.write(b"c" * 1048576)
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(level=1, threads=2)
         cobj = cctx.compressobj()
 
         chunks = []
         while True:
             d = source.read(8192)
             if not d:
                 break
 
             chunks.append(cobj.compress(d))
 
         chunks.append(cobj.flush())
 
         compressed = b"".join(chunks)
 
         self.assertEqual(len(compressed), 119)
 
     def test_frame_progression(self):
         cctx = zstd.ZstdCompressor()
 
         self.assertEqual(cctx.frame_progression(), (0, 0, 0))
 
         cobj = cctx.compressobj()
 
         cobj.compress(b"foobar")
         self.assertEqual(cctx.frame_progression(), (6, 0, 0))
 
         cobj.flush()
         self.assertEqual(cctx.frame_progression(), (6, 6, 15))
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         cobj = cctx.compressobj(size=2)
         with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             cobj.compress(b"foo")
 
         # Try another operation on this instance.
         with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             cobj.compress(b"aa")
 
         # Try another operation on the compressor.
         cctx.compressobj(size=4)
         cctx.compress(b"foobar")
 
 
 @make_cffi
 class TestCompressor_copy_stream(TestCase):
     def test_no_read(self):
         source = object()
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor()
         with self.assertRaises(ValueError):
             cctx.copy_stream(source, dest)
 
     def test_no_write(self):
         source = io.BytesIO()
         dest = object()
 
         cctx = zstd.ZstdCompressor()
         with self.assertRaises(ValueError):
             cctx.copy_stream(source, dest)
 
     def test_empty(self):
         source = io.BytesIO()
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         r, w = cctx.copy_stream(source, dest)
         self.assertEqual(int(r), 0)
         self.assertEqual(w, 9)
 
-        self.assertEqual(dest.getvalue(), b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
+        self.assertEqual(
+            dest.getvalue(), b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00"
+        )
 
     def test_large_data(self):
         source = io.BytesIO()
         for i in range(255):
             source.write(struct.Struct(">B").pack(i) * 16384)
         source.seek(0)
 
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         r, w = cctx.copy_stream(source, dest)
 
         self.assertEqual(r, 255 * 16384)
         self.assertEqual(w, 999)
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
     def test_write_checksum(self):
         source = io.BytesIO(b"foobar")
         no_checksum = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1)
         cctx.copy_stream(source, no_checksum)
 
         source.seek(0)
         with_checksum = io.BytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         cctx.copy_stream(source, with_checksum)
 
-        self.assertEqual(len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4)
+        self.assertEqual(
+            len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4
+        )
 
         no_params = zstd.get_frame_parameters(no_checksum.getvalue())
         with_params = zstd.get_frame_parameters(with_checksum.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
     def test_write_content_size(self):
         source = io.BytesIO(b"foobar" * 256)
         no_size = io.BytesIO()
 
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         cctx.copy_stream(source, no_size)
 
         source.seek(0)
         with_size = io.BytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         cctx.copy_stream(source, with_size)
 
         # Source content size is unknown, so no content size written.
         self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()))
 
         source.seek(0)
         with_size = io.BytesIO()
         cctx.copy_stream(source, with_size, size=len(source.getvalue()))
 
         # We specified source size, so content size header is present.
         self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()) + 1)
 
         no_params = zstd.get_frame_parameters(no_size.getvalue())
         with_params = zstd.get_frame_parameters(with_size.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
     def test_read_write_size(self):
         source = OpCountingBytesIO(b"foobarfoobar")
         dest = OpCountingBytesIO()
         cctx = zstd.ZstdCompressor()
         r, w = cctx.copy_stream(source, dest, read_size=1, write_size=1)
 
         self.assertEqual(r, len(source.getvalue()))
         self.assertEqual(w, 21)
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
     def test_multithreaded(self):
         source = io.BytesIO()
         source.write(b"a" * 1048576)
         source.write(b"b" * 1048576)
         source.write(b"c" * 1048576)
         source.seek(0)
 
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor(threads=2, write_content_size=False)
         r, w = cctx.copy_stream(source, dest)
         self.assertEqual(r, 3145728)
         self.assertEqual(w, 111)
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Writing content size and checksum works.
         cctx = zstd.ZstdCompressor(threads=2, write_checksum=True)
         dest = io.BytesIO()
         source.seek(0)
         cctx.copy_stream(source, dest, size=len(source.getvalue()))
 
         params = zstd.get_frame_parameters(dest.getvalue())
         self.assertEqual(params.content_size, 3145728)
         self.assertEqual(params.dict_id, 0)
         self.assertTrue(params.has_checksum)
 
     def test_bad_size(self):
         source = io.BytesIO()
         source.write(b"a" * 32768)
         source.write(b"b" * 32768)
         source.seek(0)
 
         dest = io.BytesIO()
 
         cctx = zstd.ZstdCompressor()
 
         with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             cctx.copy_stream(source, dest, size=42)
 
         # Try another operation on this compressor.
         source.seek(0)
         dest = io.BytesIO()
         cctx.copy_stream(source, dest)
 
 
 @make_cffi
 class TestCompressor_stream_reader(TestCase):
     def test_context_manager(self):
         cctx = zstd.ZstdCompressor()
 
         with cctx.stream_reader(b"foo") as reader:
-            with self.assertRaisesRegex(ValueError, "cannot __enter__ multiple times"):
+            with self.assertRaisesRegex(
+                ValueError, "cannot __enter__ multiple times"
+            ):
                 with reader as reader2:
                     pass
 
     def test_no_context_manager(self):
         cctx = zstd.ZstdCompressor()
 
         reader = cctx.stream_reader(b"foo")
         reader.read(4)
         self.assertFalse(reader.closed)
 
         reader.close()
         self.assertTrue(reader.closed)
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(1)
 
     def test_not_implemented(self):
         cctx = zstd.ZstdCompressor()
 
         with cctx.stream_reader(b"foo" * 60) as reader:
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readline()
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readlines()
 
             with self.assertRaises(io.UnsupportedOperation):
                 iter(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
                 next(reader)
 
             with self.assertRaises(OSError):
                 reader.writelines([])
 
             with self.assertRaises(OSError):
                 reader.write(b"foo")
 
     def test_constant_methods(self):
         cctx = zstd.ZstdCompressor()
 
         with cctx.stream_reader(b"boo") as reader:
             self.assertTrue(reader.readable())
             self.assertFalse(reader.writable())
             self.assertFalse(reader.seekable())
             self.assertFalse(reader.isatty())
             self.assertFalse(reader.closed)
             self.assertIsNone(reader.flush())
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_closed(self):
         cctx = zstd.ZstdCompressor()
 
         with cctx.stream_reader(b"foo" * 60) as reader:
             reader.close()
             self.assertTrue(reader.closed)
             with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(10)
 
     def test_read_sizes(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         with cctx.stream_reader(b"foo") as reader:
             with self.assertRaisesRegex(
                 ValueError, "cannot read negative amounts less than -1"
             ):
                 reader.read(-2)
 
             self.assertEqual(reader.read(0), b"")
             self.assertEqual(reader.read(), foo)
 
     def test_read_buffer(self):
         cctx = zstd.ZstdCompressor()
 
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         with cctx.stream_reader(source) as reader:
             self.assertEqual(reader.tell(), 0)
 
             # We should get entire frame in one read.
             result = reader.read(8192)
             self.assertEqual(result, frame)
             self.assertEqual(reader.tell(), len(result))
             self.assertEqual(reader.read(), b"")
             self.assertEqual(reader.tell(), len(result))
 
     def test_read_buffer_small_chunks(self):
         cctx = zstd.ZstdCompressor()
 
         source = b"foo" * 60
         chunks = []
 
         with cctx.stream_reader(source) as reader:
             self.assertEqual(reader.tell(), 0)
 
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
         self.assertEqual(b"".join(chunks), cctx.compress(source))
 
     def test_read_stream(self):
         cctx = zstd.ZstdCompressor()
 
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         with cctx.stream_reader(io.BytesIO(source), size=len(source)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             chunk = reader.read(8192)
             self.assertEqual(chunk, frame)
             self.assertEqual(reader.tell(), len(chunk))
             self.assertEqual(reader.read(), b"")
             self.assertEqual(reader.tell(), len(chunk))
 
     def test_read_stream_small_chunks(self):
         cctx = zstd.ZstdCompressor()
 
         source = b"foo" * 60
         chunks = []
 
         with cctx.stream_reader(io.BytesIO(source), size=len(source)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
         self.assertEqual(b"".join(chunks), cctx.compress(source))
 
     def test_read_after_exit(self):
         cctx = zstd.ZstdCompressor()
 
         with cctx.stream_reader(b"foo" * 60) as reader:
             while reader.read(8192):
                 pass
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(10)
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         source = io.BytesIO(b"foobar")
 
         with cctx.stream_reader(source, size=2) as reader:
-            with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
+            with self.assertRaisesRegex(
+                zstd.ZstdError, "Src size is incorrect"
+            ):
                 reader.read(10)
 
         # Try another compression operation.
         with cctx.stream_reader(source, size=42):
             pass
 
     def test_readall(self):
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(b"foo" * 1024)
 
         reader = cctx.stream_reader(b"foo" * 1024)
         self.assertEqual(reader.readall(), frame)
 
     def test_readinto(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         reader = cctx.stream_reader(b"foo")
         with self.assertRaises(Exception):
             reader.readinto(b"foobar")
 
         # readinto() with sufficiently large destination.
         b = bytearray(1024)
         reader = cctx.stream_reader(b"foo")
         self.assertEqual(reader.readinto(b), len(foo))
         self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(reader.readinto(b), 0)
         self.assertEqual(b[0 : len(foo)], foo)
 
         # readinto() with small reads.
         b = bytearray(1024)
         reader = cctx.stream_reader(b"foo", read_size=1)
         self.assertEqual(reader.readinto(b), len(foo))
         self.assertEqual(b[0 : len(foo)], foo)
 
         # Too small destination buffer.
         b = bytearray(2)
         reader = cctx.stream_reader(b"foo")
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[0:2])
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[2:4])
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], foo[4:6])
 
     def test_readinto1(self):
         cctx = zstd.ZstdCompressor()
         foo = b"".join(cctx.read_to_iter(io.BytesIO(b"foo")))
 
         reader = cctx.stream_reader(b"foo")
         with self.assertRaises(Exception):
             reader.readinto1(b"foobar")
 
         b = bytearray(1024)
         source = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(source)
         self.assertEqual(reader.readinto1(b), len(foo))
         self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(source._read_count, 2)
 
         # readinto1() with small reads.
         b = bytearray(1024)
         source = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(source, read_size=1)
         self.assertEqual(reader.readinto1(b), len(foo))
         self.assertEqual(b[0 : len(foo)], foo)
         self.assertEqual(source._read_count, 4)
 
     def test_read1(self):
         cctx = zstd.ZstdCompressor()
         foo = b"".join(cctx.read_to_iter(io.BytesIO(b"foo")))
 
         b = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(b)
 
         self.assertEqual(reader.read1(), foo)
         self.assertEqual(b._read_count, 2)
 
         b = OpCountingBytesIO(b"foo")
         reader = cctx.stream_reader(b)
 
         self.assertEqual(reader.read1(0), b"")
         self.assertEqual(reader.read1(2), foo[0:2])
         self.assertEqual(b._read_count, 2)
         self.assertEqual(reader.read1(2), foo[2:4])
         self.assertEqual(reader.read1(1024), foo[4:])
 
 
 @make_cffi
 class TestCompressor_stream_writer(TestCase):
     def test_io_api(self):
         buffer = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         writer = cctx.stream_writer(buffer)
 
         self.assertFalse(writer.isatty())
         self.assertFalse(writer.readable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(hint=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(0)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(10, os.SEEK_SET)
 
         self.assertFalse(writer.seekable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(size=42)
 
         self.assertTrue(writer.writable())
 
         with self.assertRaises(NotImplementedError):
             writer.writelines([])
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readall()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readinto(None)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.fileno()
 
         self.assertFalse(writer.closed)
 
     def test_fileno_file(self):
         with tempfile.TemporaryFile("wb") as tf:
             cctx = zstd.ZstdCompressor()
             writer = cctx.stream_writer(tf)
 
             self.assertEqual(writer.fileno(), tf.fileno())
 
     def test_close(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         writer = cctx.stream_writer(buffer)
 
         writer.write(b"foo" * 1024)
         self.assertFalse(writer.closed)
         self.assertFalse(buffer.closed)
         writer.close()
         self.assertTrue(writer.closed)
         self.assertTrue(buffer.closed)
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.write(b"foo")
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.flush()
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             with writer:
                 pass
 
         self.assertEqual(
             buffer.getvalue(),
             b"\x28\xb5\x2f\xfd\x00\x48\x55\x00\x00\x18\x66\x6f"
             b"\x6f\x01\x00\xfa\xd3\x77\x43",
         )
 
         # Context manager exit should close stream.
         buffer = io.BytesIO()
         writer = cctx.stream_writer(buffer)
 
         with writer:
             writer.write(b"foo")
 
         self.assertTrue(writer.closed)
 
     def test_empty(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         with cctx.stream_writer(buffer) as compressor:
             compressor.write(b"")
 
         result = buffer.getvalue()
         self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Test without context manager.
         buffer = io.BytesIO()
         compressor = cctx.stream_writer(buffer)
         self.assertEqual(compressor.write(b""), 0)
         self.assertEqual(buffer.getvalue(), b"")
         self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 9)
         result = buffer.getvalue()
         self.assertEqual(result, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         params = zstd.get_frame_parameters(result)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 524288)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Test write_return_read=True
         compressor = cctx.stream_writer(buffer, write_return_read=True)
         self.assertEqual(compressor.write(b""), 0)
 
     def test_input_types(self):
         expected = b"\x28\xb5\x2f\xfd\x00\x48\x19\x00\x00\x66\x6f\x6f"
         cctx = zstd.ZstdCompressor(level=1)
 
         mutable_array = bytearray(3)
         mutable_array[:] = b"foo"
 
         sources = [
             memoryview(b"foo"),
             bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             buffer = NonClosingBytesIO()
             with cctx.stream_writer(buffer) as compressor:
                 compressor.write(source)
 
             self.assertEqual(buffer.getvalue(), expected)
 
             compressor = cctx.stream_writer(buffer, write_return_read=True)
             self.assertEqual(compressor.write(source), len(source))
 
     def test_multiple_compress(self):
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=5)
         with cctx.stream_writer(buffer) as compressor:
             self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(compressor.write(b"x" * 8192), 0)
 
         result = buffer.getvalue()
         self.assertEqual(
             result,
             b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f"
             b"\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23",
         )
 
         # Test without context manager.
         buffer = io.BytesIO()
         compressor = cctx.stream_writer(buffer)
         self.assertEqual(compressor.write(b"foo"), 0)
         self.assertEqual(compressor.write(b"bar"), 0)
         self.assertEqual(compressor.write(b"x" * 8192), 0)
         self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
         result = buffer.getvalue()
         self.assertEqual(
             result,
             b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x38\x66\x6f"
             b"\x6f\x62\x61\x72\x78\x01\x00\xfc\xdf\x03\x23",
         )
 
         # Test with write_return_read=True.
         compressor = cctx.stream_writer(buffer, write_return_read=True)
         self.assertEqual(compressor.write(b"foo"), 3)
         self.assertEqual(compressor.write(b"barbiz"), 6)
         self.assertEqual(compressor.write(b"x" * 8192), 8192)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         h = hashlib.sha1(d.as_bytes()).hexdigest()
         self.assertEqual(h, "7a2e59a876db958f74257141045af8f912e00d4e")
 
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=9, dict_data=d)
         with cctx.stream_writer(buffer) as compressor:
             self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(compressor.write(b"foo" * 16384), 0)
 
         compressed = buffer.getvalue()
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 2097152)
         self.assertEqual(params.dict_id, d.dict_id())
         self.assertFalse(params.has_checksum)
 
         h = hashlib.sha1(compressed).hexdigest()
         self.assertEqual(h, "0a7c05635061f58039727cdbe76388c6f4cfef06")
 
         source = b"foo" + b"bar" + (b"foo" * 16384)
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
 
         self.assertEqual(
             dctx.decompress(compressed, max_output_size=len(source)), source
         )
 
     def test_compression_params(self):
         params = zstd.ZstdCompressionParameters(
             window_log=20,
             chain_log=6,
             hash_log=12,
             min_match=5,
             search_log=4,
             target_length=10,
             strategy=zstd.STRATEGY_FAST,
         )
 
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(compression_params=params)
         with cctx.stream_writer(buffer) as compressor:
             self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(compressor.write(b"foobar" * 16384), 0)
 
         compressed = buffer.getvalue()
 
         params = zstd.get_frame_parameters(compressed)
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1048576)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         h = hashlib.sha1(compressed).hexdigest()
         self.assertEqual(h, "dd4bb7d37c1a0235b38a2f6b462814376843ef0b")
 
     def test_write_checksum(self):
         no_checksum = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(no_checksum) as compressor:
             self.assertEqual(compressor.write(b"foobar"), 0)
 
         with_checksum = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True)
         with cctx.stream_writer(with_checksum) as compressor:
             self.assertEqual(compressor.write(b"foobar"), 0)
 
         no_params = zstd.get_frame_parameters(no_checksum.getvalue())
         with_params = zstd.get_frame_parameters(with_checksum.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertTrue(with_params.has_checksum)
 
-        self.assertEqual(len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4)
+        self.assertEqual(
+            len(with_checksum.getvalue()), len(no_checksum.getvalue()) + 4
+        )
 
     def test_write_content_size(self):
         no_size = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         with cctx.stream_writer(no_size) as compressor:
             self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         with_size = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(with_size) as compressor:
             self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         # Source size is not known in streaming mode, so header not
         # written.
         self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()))
 
         # Declaring size will write the header.
         with_size = NonClosingBytesIO()
-        with cctx.stream_writer(with_size, size=len(b"foobar" * 256)) as compressor:
+        with cctx.stream_writer(
+            with_size, size=len(b"foobar" * 256)
+        ) as compressor:
             self.assertEqual(compressor.write(b"foobar" * 256), 0)
 
         no_params = zstd.get_frame_parameters(no_size.getvalue())
         with_params = zstd.get_frame_parameters(with_size.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, 1536)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, 0)
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
         self.assertEqual(len(with_size.getvalue()), len(no_size.getvalue()) + 1)
 
     def test_no_dict_id(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(1024, samples)
 
         with_dict_id = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         with cctx.stream_writer(with_dict_id) as compressor:
             self.assertEqual(compressor.write(b"foobarfoobar"), 0)
 
         self.assertEqual(with_dict_id.getvalue()[4:5], b"\x03")
 
         cctx = zstd.ZstdCompressor(level=1, dict_data=d, write_dict_id=False)
         no_dict_id = NonClosingBytesIO()
         with cctx.stream_writer(no_dict_id) as compressor:
             self.assertEqual(compressor.write(b"foobarfoobar"), 0)
 
         self.assertEqual(no_dict_id.getvalue()[4:5], b"\x00")
 
         no_params = zstd.get_frame_parameters(no_dict_id.getvalue())
         with_params = zstd.get_frame_parameters(with_dict_id.getvalue())
         self.assertEqual(no_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(with_params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(no_params.dict_id, 0)
         self.assertEqual(with_params.dict_id, d.dict_id())
         self.assertFalse(no_params.has_checksum)
         self.assertFalse(with_params.has_checksum)
 
-        self.assertEqual(len(with_dict_id.getvalue()), len(no_dict_id.getvalue()) + 4)
+        self.assertEqual(
+            len(with_dict_id.getvalue()), len(no_dict_id.getvalue()) + 4
+        )
 
     def test_memory_size(self):
         cctx = zstd.ZstdCompressor(level=3)
         buffer = io.BytesIO()
         with cctx.stream_writer(buffer) as compressor:
             compressor.write(b"foo")
             size = compressor.memory_size()
 
         self.assertGreater(size, 100000)
 
     def test_write_size(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest, write_size=1) as compressor:
             self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(compressor.write(b"foobar"), 0)
 
         self.assertEqual(len(dest.getvalue()), dest._write_count)
 
     def test_flush_repeated(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest) as compressor:
             self.assertEqual(compressor.write(b"foo"), 0)
             self.assertEqual(dest._write_count, 0)
             self.assertEqual(compressor.flush(), 12)
             self.assertEqual(dest._write_count, 1)
             self.assertEqual(compressor.write(b"bar"), 0)
             self.assertEqual(dest._write_count, 1)
             self.assertEqual(compressor.flush(), 6)
             self.assertEqual(dest._write_count, 2)
             self.assertEqual(compressor.write(b"baz"), 0)
 
         self.assertEqual(dest._write_count, 3)
 
     def test_flush_empty_block(self):
         cctx = zstd.ZstdCompressor(level=3, write_checksum=True)
         dest = OpCountingBytesIO()
         with cctx.stream_writer(dest) as compressor:
             self.assertEqual(compressor.write(b"foobar" * 8192), 0)
             count = dest._write_count
             offset = dest.tell()
             self.assertEqual(compressor.flush(), 23)
             self.assertGreater(dest._write_count, count)
             self.assertGreater(dest.tell(), offset)
             offset = dest.tell()
             # Ending the write here should cause an empty block to be written
             # to denote end of frame.
 
         trailing = dest.getvalue()[offset:]
         # 3 bytes block header + 4 bytes frame checksum
         self.assertEqual(len(trailing), 7)
 
         header = trailing[0:3]
         self.assertEqual(header, b"\x01\x00\x00")
 
     def test_flush_frame(self):
         cctx = zstd.ZstdCompressor(level=3)
         dest = OpCountingBytesIO()
 
         with cctx.stream_writer(dest) as compressor:
             self.assertEqual(compressor.write(b"foobar" * 8192), 0)
             self.assertEqual(compressor.flush(zstd.FLUSH_FRAME), 23)
             compressor.write(b"biz" * 16384)
 
         self.assertEqual(
             dest.getvalue(),
             # Frame 1.
             b"\x28\xb5\x2f\xfd\x00\x58\x75\x00\x00\x30\x66\x6f\x6f"
             b"\x62\x61\x72\x01\x00\xf7\xbf\xe8\xa5\x08"
             # Frame 2.
             b"\x28\xb5\x2f\xfd\x00\x58\x5d\x00\x00\x18\x62\x69\x7a"
             b"\x01\x00\xfa\x3f\x75\x37\x04",
         )
 
     def test_bad_flush_mode(self):
         cctx = zstd.ZstdCompressor()
         dest = io.BytesIO()
         with cctx.stream_writer(dest) as compressor:
             with self.assertRaisesRegex(ValueError, "unknown flush_mode: 42"):
                 compressor.flush(flush_mode=42)
 
     def test_multithreaded(self):
         dest = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(threads=2)
         with cctx.stream_writer(dest) as compressor:
             compressor.write(b"a" * 1048576)
             compressor.write(b"b" * 1048576)
             compressor.write(b"c" * 1048576)
 
         self.assertEqual(len(dest.getvalue()), 111)
 
     def test_tell(self):
         dest = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         with cctx.stream_writer(dest) as compressor:
             self.assertEqual(compressor.tell(), 0)
 
             for i in range(256):
                 compressor.write(b"foo" * (i + 1))
                 self.assertEqual(compressor.tell(), dest.tell())
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         dest = io.BytesIO()
 
         with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             with cctx.stream_writer(dest, size=2) as compressor:
                 compressor.write(b"foo")
 
         # Test another operation.
         with cctx.stream_writer(dest, size=42):
             pass
 
     def test_tarfile_compat(self):
         dest = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor()
         with cctx.stream_writer(dest) as compressor:
             with tarfile.open("tf", mode="w|", fileobj=compressor) as tf:
                 tf.add(__file__, "test_compressor.py")
 
         dest = io.BytesIO(dest.getvalue())
 
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_reader(dest) as reader:
             with tarfile.open(mode="r|", fileobj=reader) as tf:
                 for member in tf:
                     self.assertEqual(member.name, "test_compressor.py")
 
 
 @make_cffi
 class TestCompressor_read_to_iter(TestCase):
     def test_type_validation(self):
         cctx = zstd.ZstdCompressor()
 
         # Object with read() works.
         for chunk in cctx.read_to_iter(io.BytesIO()):
             pass
 
         # Buffer protocol works.
         for chunk in cctx.read_to_iter(b"foobar"):
             pass
 
-        with self.assertRaisesRegex(ValueError, "must pass an object with a read"):
+        with self.assertRaisesRegex(
+            ValueError, "must pass an object with a read"
+        ):
             for chunk in cctx.read_to_iter(True):
                 pass
 
     def test_read_empty(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         source = io.BytesIO()
         it = cctx.read_to_iter(source)
         chunks = list(it)
         self.assertEqual(len(chunks), 1)
         compressed = b"".join(chunks)
         self.assertEqual(compressed, b"\x28\xb5\x2f\xfd\x00\x48\x01\x00\x00")
 
         # And again with the buffer protocol.
         it = cctx.read_to_iter(b"")
         chunks = list(it)
         self.assertEqual(len(chunks), 1)
         compressed2 = b"".join(chunks)
         self.assertEqual(compressed2, compressed)
 
     def test_read_large(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
 
         source = io.BytesIO()
         source.write(b"f" * zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE)
         source.write(b"o")
         source.seek(0)
 
         # Creating an iterator should not perform any compression until
         # first read.
         it = cctx.read_to_iter(source, size=len(source.getvalue()))
         self.assertEqual(source.tell(), 0)
 
         # We should have exactly 2 output chunks.
         chunks = []
         chunk = next(it)
         self.assertIsNotNone(chunk)
         self.assertEqual(source.tell(), zstd.COMPRESSION_RECOMMENDED_INPUT_SIZE)
         chunks.append(chunk)
         chunk = next(it)
         self.assertIsNotNone(chunk)
         chunks.append(chunk)
 
         self.assertEqual(source.tell(), len(source.getvalue()))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         # And again for good measure.
         with self.assertRaises(StopIteration):
             next(it)
 
         # We should get the same output as the one-shot compression mechanism.
         self.assertEqual(b"".join(chunks), cctx.compress(source.getvalue()))
 
         params = zstd.get_frame_parameters(b"".join(chunks))
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Now check the buffer protocol.
         it = cctx.read_to_iter(source.getvalue())
         chunks = list(it)
         self.assertEqual(len(chunks), 2)
 
         params = zstd.get_frame_parameters(b"".join(chunks))
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         # self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         self.assertEqual(b"".join(chunks), cctx.compress(source.getvalue()))
 
     def test_read_write_size(self):
         source = OpCountingBytesIO(b"foobarfoobar")
         cctx = zstd.ZstdCompressor(level=3)
         for chunk in cctx.read_to_iter(source, read_size=1, write_size=1):
             self.assertEqual(len(chunk), 1)
 
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
 
     def test_multithreaded(self):
         source = io.BytesIO()
         source.write(b"a" * 1048576)
         source.write(b"b" * 1048576)
         source.write(b"c" * 1048576)
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(threads=2)
 
         compressed = b"".join(cctx.read_to_iter(source))
         self.assertEqual(len(compressed), 111)
 
     def test_bad_size(self):
         cctx = zstd.ZstdCompressor()
 
         source = io.BytesIO(b"a" * 42)
 
         with self.assertRaisesRegex(zstd.ZstdError, "Src size is incorrect"):
             b"".join(cctx.read_to_iter(source, size=2))
 
         # Test another operation on errored compressor.
         b"".join(cctx.read_to_iter(source))
 
 
 @make_cffi
 class TestCompressor_chunker(TestCase):
     def test_empty(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         chunker = cctx.chunker()
 
         it = chunker.compress(b"")
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.finish()
 
         self.assertEqual(next(it), b"\x28\xb5\x2f\xfd\x00\x58\x01\x00\x00")
 
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_simple_input(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
         it = chunker.compress(b"foobar")
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.compress(b"baz" * 30)
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.finish()
 
         self.assertEqual(
             next(it),
             b"\x28\xb5\x2f\xfd\x00\x58\x7d\x00\x00\x48\x66\x6f"
             b"\x6f\x62\x61\x72\x62\x61\x7a\x01\x00\xe4\xe4\x8e",
         )
 
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_input_size(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker(size=1024)
 
         it = chunker.compress(b"x" * 1000)
 
         with self.assertRaises(StopIteration):
             next(it)
 
         it = chunker.compress(b"y" * 24)
 
         with self.assertRaises(StopIteration):
             next(it)
 
         chunks = list(chunker.finish())
 
         self.assertEqual(
             chunks,
             [
                 b"\x28\xb5\x2f\xfd\x60\x00\x03\x65\x00\x00\x18\x78\x78\x79\x02\x00"
                 b"\xa0\x16\xe3\x2b\x80\x05"
             ],
         )
 
         dctx = zstd.ZstdDecompressor()
 
-        self.assertEqual(dctx.decompress(b"".join(chunks)), (b"x" * 1000) + (b"y" * 24))
+        self.assertEqual(
+            dctx.decompress(b"".join(chunks)), (b"x" * 1000) + (b"y" * 24)
+        )
 
     def test_small_chunk_size(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker(chunk_size=1)
 
         chunks = list(chunker.compress(b"foo" * 1024))
         self.assertEqual(chunks, [])
 
         chunks = list(chunker.finish())
         self.assertTrue(all(len(chunk) == 1 for chunk in chunks))
 
         self.assertEqual(
             b"".join(chunks),
             b"\x28\xb5\x2f\xfd\x00\x58\x55\x00\x00\x18\x66\x6f\x6f\x01\x00"
             b"\xfa\xd3\x77\x43",
         )
 
         dctx = zstd.ZstdDecompressor()
         self.assertEqual(
-            dctx.decompress(b"".join(chunks), max_output_size=10000), b"foo" * 1024
+            dctx.decompress(b"".join(chunks), max_output_size=10000),
+            b"foo" * 1024,
         )
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor()
 
         mutable_array = bytearray(3)
         mutable_array[:] = b"foo"
 
         sources = [
             memoryview(b"foo"),
             bytearray(b"foo"),
             mutable_array,
         ]
 
         for source in sources:
             chunker = cctx.chunker()
 
             self.assertEqual(list(chunker.compress(source)), [])
             self.assertEqual(
                 list(chunker.finish()),
                 [b"\x28\xb5\x2f\xfd\x00\x58\x19\x00\x00\x66\x6f\x6f"],
             )
 
     def test_flush(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
         self.assertEqual(list(chunker.compress(b"foo" * 1024)), [])
         self.assertEqual(list(chunker.compress(b"bar" * 1024)), [])
 
         chunks1 = list(chunker.flush())
 
         self.assertEqual(
             chunks1,
             [
                 b"\x28\xb5\x2f\xfd\x00\x58\x8c\x00\x00\x30\x66\x6f\x6f\x62\x61\x72"
                 b"\x02\x00\xfa\x03\xfe\xd0\x9f\xbe\x1b\x02"
             ],
         )
 
         self.assertEqual(list(chunker.flush()), [])
         self.assertEqual(list(chunker.flush()), [])
 
         self.assertEqual(list(chunker.compress(b"baz" * 1024)), [])
 
         chunks2 = list(chunker.flush())
         self.assertEqual(len(chunks2), 1)
 
         chunks3 = list(chunker.finish())
         self.assertEqual(len(chunks2), 1)
 
         dctx = zstd.ZstdDecompressor()
 
         self.assertEqual(
             dctx.decompress(
                 b"".join(chunks1 + chunks2 + chunks3), max_output_size=10000
             ),
             (b"foo" * 1024) + (b"bar" * 1024) + (b"baz" * 1024),
         )
 
     def test_compress_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
         list(chunker.compress(b"foo"))
         list(chunker.finish())
 
         with self.assertRaisesRegex(
-            zstd.ZstdError, r"cannot call compress\(\) after compression finished"
+            zstd.ZstdError,
+            r"cannot call compress\(\) after compression finished",
         ):
             list(chunker.compress(b"foo"))
 
     def test_flush_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
         list(chunker.compress(b"foo"))
         list(chunker.finish())
 
         with self.assertRaisesRegex(
             zstd.ZstdError, r"cannot call flush\(\) after compression finished"
         ):
             list(chunker.flush())
 
     def test_finish_after_finish(self):
         cctx = zstd.ZstdCompressor()
         chunker = cctx.chunker()
 
         list(chunker.compress(b"foo"))
         list(chunker.finish())
 
         with self.assertRaisesRegex(
             zstd.ZstdError, r"cannot call finish\(\) after compression finished"
         ):
             list(chunker.finish())
 
 
 class TestCompressor_multi_compress_to_buffer(TestCase):
     def test_invalid_inputs(self):
         cctx = zstd.ZstdCompressor()
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         with self.assertRaises(TypeError):
             cctx.multi_compress_to_buffer(True)
 
         with self.assertRaises(TypeError):
             cctx.multi_compress_to_buffer((1, 2))
 
-        with self.assertRaisesRegex(TypeError, "item 0 not a bytes like object"):
+        with self.assertRaisesRegex(
+            TypeError, "item 0 not a bytes like object"
+        ):
             cctx.multi_compress_to_buffer([u"foo"])
 
     def test_empty_input(self):
         cctx = zstd.ZstdCompressor()
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         with self.assertRaisesRegex(ValueError, "no source elements found"):
             cctx.multi_compress_to_buffer([])
 
         with self.assertRaisesRegex(ValueError, "source elements are empty"):
             cctx.multi_compress_to_buffer([b"", b"", b""])
 
     def test_list_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         original = [b"foo" * 12, b"bar" * 6]
         frames = [cctx.compress(c) for c in original]
         b = cctx.multi_compress_to_buffer(original)
 
         self.assertIsInstance(b, zstd.BufferWithSegmentsCollection)
 
         self.assertEqual(len(b), 2)
         self.assertEqual(b.size(), 44)
 
         self.assertEqual(b[0].tobytes(), frames[0])
         self.assertEqual(b[1].tobytes(), frames[1])
 
     def test_buffer_with_segments_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(c) for c in original]
 
         offsets = struct.pack(
             "=QQQQ", 0, len(original[0]), len(original[0]), len(original[1])
         )
         segments = zstd.BufferWithSegments(b"".join(original), offsets)
 
         result = cctx.multi_compress_to_buffer(segments)
 
         self.assertEqual(len(result), 2)
         self.assertEqual(result.size(), 47)
 
         self.assertEqual(result[0].tobytes(), frames[0])
         self.assertEqual(result[1].tobytes(), frames[1])
 
     def test_buffer_with_segments_collection_input(self):
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         original = [
             b"foo1",
             b"foo2" * 2,
             b"foo3" * 3,
             b"foo4" * 4,
             b"foo5" * 5,
         ]
 
         frames = [cctx.compress(c) for c in original]
 
         b = b"".join([original[0], original[1]])
         b1 = zstd.BufferWithSegments(
             b,
             struct.pack(
                 "=QQQQ", 0, len(original[0]), len(original[0]), len(original[1])
             ),
         )
         b = b"".join([original[2], original[3], original[4]])
         b2 = zstd.BufferWithSegments(
             b,
             struct.pack(
                 "=QQQQQQ",
                 0,
                 len(original[2]),
                 len(original[2]),
                 len(original[3]),
                 len(original[2]) + len(original[3]),
                 len(original[4]),
             ),
         )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
         result = cctx.multi_compress_to_buffer(c)
 
         self.assertEqual(len(result), len(frames))
 
         for i, frame in enumerate(frames):
             self.assertEqual(result[i].tobytes(), frame)
 
     def test_multiple_threads(self):
         # threads argument will cause multi-threaded ZSTD APIs to be used, which will
         # make output different.
         refcctx = zstd.ZstdCompressor(write_checksum=True)
         reference = [refcctx.compress(b"x" * 64), refcctx.compress(b"y" * 64)]
 
         cctx = zstd.ZstdCompressor(write_checksum=True)
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         frames = []
         frames.extend(b"x" * 64 for i in range(256))
         frames.extend(b"y" * 64 for i in range(256))
 
         result = cctx.multi_compress_to_buffer(frames, threads=-1)
 
         self.assertEqual(len(result), 512)
         for i in range(512):
             if i < 256:
                 self.assertEqual(result[i].tobytes(), reference[0])
             else:
                 self.assertEqual(result[i].tobytes(), reference[1])

contrib/python-zstandard/tests/test_compressor_fuzzing.py

@@ -1,836 +1,884 b''
 import io
 import os
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
     raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     NonClosingBytesIO,
     random_input_data,
     TestCase,
 )
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_stream_reader_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            -1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_stream_source_read(self, original, level, source_read_size, read_size):
+    def test_stream_source_read(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 chunk = reader.read(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            -1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_buffer_source_read(self, original, level, source_read_size, read_size):
+    def test_buffer_source_read(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 chunk = reader.read(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_stream_source_read_variance(
         self, original, level, source_read_size, read_sizes
     ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_buffer_source_read_variance(
         self, original, level, source_read_size, read_sizes
     ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_stream_source_readinto(self, original, level, source_read_size, read_size):
+    def test_stream_source_readinto(
+        self, original, level, source_read_size, read_size
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_buffer_source_readinto(self, original, level, source_read_size, read_size):
+    def test_buffer_source_readinto(
+        self, original, level, source_read_size, read_size
+    ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_stream_source_readinto_variance(
         self, original, level, source_read_size, read_sizes
     ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_buffer_source_readinto_variance(
         self, original, level, source_read_size, read_sizes
     ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            -1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_stream_source_read1(self, original, level, source_read_size, read_size):
+    def test_stream_source_read1(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 chunk = reader.read1(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(-1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            -1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
-    def test_buffer_source_read1(self, original, level, source_read_size, read_size):
+    def test_buffer_source_read1(
+        self, original, level, source_read_size, read_size
+    ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 chunk = reader.read1(read_size)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_stream_source_read1_variance(
         self, original, level, source_read_size, read_sizes
     ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_buffer_source_read1_variance(
         self, original, level, source_read_size, read_sizes
     ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 16384))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
     def test_stream_source_readinto1(
         self, original, level, source_read_size, read_size
     ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
-        read_size=strategies.integers(1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE),
+        read_size=strategies.integers(
+            1, zstd.COMPRESSION_RECOMMENDED_OUTPUT_SIZE
+        ),
     )
     def test_buffer_source_readinto1(
         self, original, level, source_read_size, read_size
     ):
         if read_size == 0:
             read_size = -1
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_stream_source_readinto1_variance(
         self, original, level, source_read_size, read_sizes
     ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             io.BytesIO(original), size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 16384),
         read_sizes=strategies.data(),
     )
     def test_buffer_source_readinto1_variance(
         self, original, level, source_read_size, read_sizes
     ):
 
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         with cctx.stream_reader(
             original, size=len(original), read_size=source_read_size
         ) as reader:
             chunks = []
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 16384))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_stream_writer_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         write_size=strategies.integers(min_value=1, max_value=1048576),
     )
     def test_write_size_variance(self, original, level, write_size):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         b = NonClosingBytesIO()
         with cctx.stream_writer(
             b, size=len(original), write_size=write_size
         ) as compressor:
             compressor.write(original)
 
         self.assertEqual(b.getvalue(), ref_frame)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_copy_stream_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         read_size=strategies.integers(min_value=1, max_value=1048576),
         write_size=strategies.integers(min_value=1, max_value=1048576),
     )
-    def test_read_write_size_variance(self, original, level, read_size, write_size):
+    def test_read_write_size_variance(
+        self, original, level, read_size, write_size
+    ):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         source = io.BytesIO(original)
         dest = io.BytesIO()
 
         cctx.copy_stream(
-            source, dest, size=len(original), read_size=read_size, write_size=write_size
+            source,
+            dest,
+            size=len(original),
+            read_size=read_size,
+            write_size=write_size,
         )
 
         self.assertEqual(dest.getvalue(), ref_frame)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_compressobj_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         chunk_sizes=strategies.data(),
     )
     def test_random_input_sizes(self, original, level, chunk_sizes):
         refctx = zstd.ZstdCompressor(level=level)
         ref_frame = refctx.compress(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         cobj = cctx.compressobj(size=len(original))
 
         chunks = []
         i = 0
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
             source = original[i : i + chunk_size]
             if not source:
                 break
 
             chunks.append(cobj.compress(source))
             i += chunk_size
 
         chunks.append(cobj.flush())
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         chunk_sizes=strategies.data(),
         flushes=strategies.data(),
     )
     def test_flush_block(self, original, level, chunk_sizes, flushes):
         cctx = zstd.ZstdCompressor(level=level)
         cobj = cctx.compressobj()
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         compressed_chunks = []
         decompressed_chunks = []
         i = 0
         while True:
             input_size = chunk_sizes.draw(strategies.integers(1, 4096))
             source = original[i : i + input_size]
             if not source:
                 break
 
             i += input_size
 
             chunk = cobj.compress(source)
             compressed_chunks.append(chunk)
             decompressed_chunks.append(dobj.decompress(chunk))
 
             if not flushes.draw(strategies.booleans()):
                 continue
 
             chunk = cobj.flush(zstd.COMPRESSOBJ_FLUSH_BLOCK)
             compressed_chunks.append(chunk)
             decompressed_chunks.append(dobj.decompress(chunk))
 
             self.assertEqual(b"".join(decompressed_chunks), original[0:i])
 
         chunk = cobj.flush(zstd.COMPRESSOBJ_FLUSH_FINISH)
         compressed_chunks.append(chunk)
         decompressed_chunks.append(dobj.decompress(chunk))
 
         self.assertEqual(
-            dctx.decompress(b"".join(compressed_chunks), max_output_size=len(original)),
+            dctx.decompress(
+                b"".join(compressed_chunks), max_output_size=len(original)
+            ),
             original,
         )
         self.assertEqual(b"".join(decompressed_chunks), original)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_read_to_iter_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         read_size=strategies.integers(min_value=1, max_value=4096),
         write_size=strategies.integers(min_value=1, max_value=4096),
     )
-    def test_read_write_size_variance(self, original, level, read_size, write_size):
+    def test_read_write_size_variance(
+        self, original, level, read_size, write_size
+    ):
         refcctx = zstd.ZstdCompressor(level=level)
         ref_frame = refcctx.compress(original)
 
         source = io.BytesIO(original)
 
         cctx = zstd.ZstdCompressor(level=level)
         chunks = list(
             cctx.read_to_iter(
-                source, size=len(original), read_size=read_size, write_size=write_size
+                source,
+                size=len(original),
+                read_size=read_size,
+                write_size=write_size,
             )
         )
 
         self.assertEqual(b"".join(chunks), ref_frame)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 class TestCompressor_multi_compress_to_buffer_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.lists(
-            strategies.sampled_from(random_input_data()), min_size=1, max_size=1024
+            strategies.sampled_from(random_input_data()),
+            min_size=1,
+            max_size=1024,
         ),
         threads=strategies.integers(min_value=1, max_value=8),
         use_dict=strategies.booleans(),
     )
     def test_data_equivalence(self, original, threads, use_dict):
         kwargs = {}
 
         # Use a content dictionary because it is cheap to create.
         if use_dict:
             kwargs["dict_data"] = zstd.ZstdCompressionDict(original[0])
 
         cctx = zstd.ZstdCompressor(level=1, write_checksum=True, **kwargs)
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         result = cctx.multi_compress_to_buffer(original, threads=-1)
 
         self.assertEqual(len(result), len(original))
 
         # The frame produced via the batch APIs may not be bit identical to that
         # produced by compress() because compression parameters are adjusted
         # from the first input in batch mode. So the only thing we can do is
         # verify the decompressed data matches the input.
         dctx = zstd.ZstdDecompressor(**kwargs)
 
         for i, frame in enumerate(result):
             self.assertEqual(dctx.decompress(frame), original[i])
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestCompressor_chunker_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         chunk_size=strategies.integers(min_value=1, max_value=32 * 1048576),
         input_sizes=strategies.data(),
     )
     def test_random_input_sizes(self, original, level, chunk_size, input_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         chunker = cctx.chunker(chunk_size=chunk_size)
 
         chunks = []
         i = 0
         while True:
             input_size = input_sizes.draw(strategies.integers(1, 4096))
             source = original[i : i + input_size]
             if not source:
                 break
 
             chunks.extend(chunker.compress(source))
             i += input_size
 
         chunks.extend(chunker.finish())
 
         dctx = zstd.ZstdDecompressor()
 
         self.assertEqual(
-            dctx.decompress(b"".join(chunks), max_output_size=len(original)), original
+            dctx.decompress(b"".join(chunks), max_output_size=len(original)),
+            original,
         )
 
         self.assertTrue(all(len(chunk) == chunk_size for chunk in chunks[:-1]))
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         chunk_size=strategies.integers(min_value=1, max_value=32 * 1048576),
         input_sizes=strategies.data(),
         flushes=strategies.data(),
     )
-    def test_flush_block(self, original, level, chunk_size, input_sizes, flushes):
+    def test_flush_block(
+        self, original, level, chunk_size, input_sizes, flushes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         chunker = cctx.chunker(chunk_size=chunk_size)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         compressed_chunks = []
         decompressed_chunks = []
         i = 0
         while True:
             input_size = input_sizes.draw(strategies.integers(1, 4096))
             source = original[i : i + input_size]
             if not source:
                 break
 
             i += input_size
 
             chunks = list(chunker.compress(source))
             compressed_chunks.extend(chunks)
             decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
             if not flushes.draw(strategies.booleans()):
                 continue
 
             chunks = list(chunker.flush())
             compressed_chunks.extend(chunks)
             decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
             self.assertEqual(b"".join(decompressed_chunks), original[0:i])
 
         chunks = list(chunker.finish())
         compressed_chunks.extend(chunks)
         decompressed_chunks.append(dobj.decompress(b"".join(chunks)))
 
         self.assertEqual(
-            dctx.decompress(b"".join(compressed_chunks), max_output_size=len(original)),
+            dctx.decompress(
+                b"".join(compressed_chunks), max_output_size=len(original)
+            ),
             original,
         )
         self.assertEqual(b"".join(decompressed_chunks), original)

contrib/python-zstandard/tests/test_data_structures.py

@@ -1,241 +1,255 b''
 import sys
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     TestCase,
 )
 
 
 @make_cffi
 class TestCompressionParameters(TestCase):
     def test_bounds(self):
         zstd.ZstdCompressionParameters(
             window_log=zstd.WINDOWLOG_MIN,
             chain_log=zstd.CHAINLOG_MIN,
             hash_log=zstd.HASHLOG_MIN,
             search_log=zstd.SEARCHLOG_MIN,
             min_match=zstd.MINMATCH_MIN + 1,
             target_length=zstd.TARGETLENGTH_MIN,
             strategy=zstd.STRATEGY_FAST,
         )
 
         zstd.ZstdCompressionParameters(
             window_log=zstd.WINDOWLOG_MAX,
             chain_log=zstd.CHAINLOG_MAX,
             hash_log=zstd.HASHLOG_MAX,
             search_log=zstd.SEARCHLOG_MAX,
             min_match=zstd.MINMATCH_MAX - 1,
             target_length=zstd.TARGETLENGTH_MAX,
             strategy=zstd.STRATEGY_BTULTRA2,
         )
 
     def test_from_level(self):
         p = zstd.ZstdCompressionParameters.from_level(1)
         self.assertIsInstance(p, zstd.CompressionParameters)
 
         self.assertEqual(p.window_log, 19)
 
         p = zstd.ZstdCompressionParameters.from_level(-4)
         self.assertEqual(p.window_log, 19)
 
     def test_members(self):
         p = zstd.ZstdCompressionParameters(
             window_log=10,
             chain_log=6,
             hash_log=7,
             search_log=4,
             min_match=5,
             target_length=8,
             strategy=1,
         )
         self.assertEqual(p.window_log, 10)
         self.assertEqual(p.chain_log, 6)
         self.assertEqual(p.hash_log, 7)
         self.assertEqual(p.search_log, 4)
         self.assertEqual(p.min_match, 5)
         self.assertEqual(p.target_length, 8)
         self.assertEqual(p.compression_strategy, 1)
 
         p = zstd.ZstdCompressionParameters(compression_level=2)
         self.assertEqual(p.compression_level, 2)
 
         p = zstd.ZstdCompressionParameters(threads=4)
         self.assertEqual(p.threads, 4)
 
-        p = zstd.ZstdCompressionParameters(threads=2, job_size=1048576, overlap_log=6)
+        p = zstd.ZstdCompressionParameters(
+            threads=2, job_size=1048576, overlap_log=6
+        )
         self.assertEqual(p.threads, 2)
         self.assertEqual(p.job_size, 1048576)
         self.assertEqual(p.overlap_log, 6)
         self.assertEqual(p.overlap_size_log, 6)
 
         p = zstd.ZstdCompressionParameters(compression_level=-1)
         self.assertEqual(p.compression_level, -1)
 
         p = zstd.ZstdCompressionParameters(compression_level=-2)
         self.assertEqual(p.compression_level, -2)
 
         p = zstd.ZstdCompressionParameters(force_max_window=True)
         self.assertEqual(p.force_max_window, 1)
 
         p = zstd.ZstdCompressionParameters(enable_ldm=True)
         self.assertEqual(p.enable_ldm, 1)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_log=7)
         self.assertEqual(p.ldm_hash_log, 7)
 
         p = zstd.ZstdCompressionParameters(ldm_min_match=6)
         self.assertEqual(p.ldm_min_match, 6)
 
         p = zstd.ZstdCompressionParameters(ldm_bucket_size_log=7)
         self.assertEqual(p.ldm_bucket_size_log, 7)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
         self.assertEqual(p.ldm_hash_every_log, 8)
         self.assertEqual(p.ldm_hash_rate_log, 8)
 
     def test_estimated_compression_context_size(self):
         p = zstd.ZstdCompressionParameters(
             window_log=20,
             chain_log=16,
             hash_log=17,
             search_log=1,
             min_match=5,
             target_length=16,
             strategy=zstd.STRATEGY_DFAST,
         )
 
         # 32-bit has slightly different values from 64-bit.
         self.assertAlmostEqual(
             p.estimated_compression_context_size(), 1294464, delta=400
         )
 
     def test_strategy(self):
         with self.assertRaisesRegex(
             ValueError, "cannot specify both compression_strategy"
         ):
             zstd.ZstdCompressionParameters(strategy=0, compression_strategy=0)
 
         p = zstd.ZstdCompressionParameters(strategy=2)
         self.assertEqual(p.compression_strategy, 2)
 
         p = zstd.ZstdCompressionParameters(strategy=3)
         self.assertEqual(p.compression_strategy, 3)
 
     def test_ldm_hash_rate_log(self):
         with self.assertRaisesRegex(
             ValueError, "cannot specify both ldm_hash_rate_log"
         ):
-            zstd.ZstdCompressionParameters(ldm_hash_rate_log=8, ldm_hash_every_log=4)
+            zstd.ZstdCompressionParameters(
+                ldm_hash_rate_log=8, ldm_hash_every_log=4
+            )
 
         p = zstd.ZstdCompressionParameters(ldm_hash_rate_log=8)
         self.assertEqual(p.ldm_hash_every_log, 8)
 
         p = zstd.ZstdCompressionParameters(ldm_hash_every_log=16)
         self.assertEqual(p.ldm_hash_every_log, 16)
 
     def test_overlap_log(self):
-        with self.assertRaisesRegex(ValueError, "cannot specify both overlap_log"):
+        with self.assertRaisesRegex(
+            ValueError, "cannot specify both overlap_log"
+        ):
             zstd.ZstdCompressionParameters(overlap_log=1, overlap_size_log=9)
 
         p = zstd.ZstdCompressionParameters(overlap_log=2)
         self.assertEqual(p.overlap_log, 2)
         self.assertEqual(p.overlap_size_log, 2)
 
         p = zstd.ZstdCompressionParameters(overlap_size_log=4)
         self.assertEqual(p.overlap_log, 4)
         self.assertEqual(p.overlap_size_log, 4)
 
 
 @make_cffi
 class TestFrameParameters(TestCase):
     def test_invalid_type(self):
         with self.assertRaises(TypeError):
             zstd.get_frame_parameters(None)
 
         # Python 3 doesn't appear to convert unicode to Py_buffer.
         if sys.version_info[0] >= 3:
             with self.assertRaises(TypeError):
                 zstd.get_frame_parameters(u"foobarbaz")
         else:
             # CPython will convert unicode to Py_buffer. But CFFI won't.
             if zstd.backend == "cffi":
                 with self.assertRaises(TypeError):
                     zstd.get_frame_parameters(u"foobarbaz")
             else:
                 with self.assertRaises(zstd.ZstdError):
                     zstd.get_frame_parameters(u"foobarbaz")
 
     def test_invalid_input_sizes(self):
-        with self.assertRaisesRegex(zstd.ZstdError, "not enough data for frame"):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "not enough data for frame"
+        ):
             zstd.get_frame_parameters(b"")
 
-        with self.assertRaisesRegex(zstd.ZstdError, "not enough data for frame"):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "not enough data for frame"
+        ):
             zstd.get_frame_parameters(zstd.FRAME_HEADER)
 
     def test_invalid_frame(self):
         with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
             zstd.get_frame_parameters(b"foobarbaz")
 
     def test_attributes(self):
         params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x00\x00")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Lowest 2 bits indicate a dictionary and length. Here, the dict id is 1 byte.
         params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x01\x00\xff")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 255)
         self.assertFalse(params.has_checksum)
 
         # Lowest 3rd bit indicates if checksum is present.
         params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x04\x00")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertTrue(params.has_checksum)
 
         # Upper 2 bits indicate content size.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x40\x00\xff\x00")
+        params = zstd.get_frame_parameters(
+            zstd.FRAME_HEADER + b"\x40\x00\xff\x00"
+        )
         self.assertEqual(params.content_size, 511)
         self.assertEqual(params.window_size, 1024)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Window descriptor is 2nd byte after frame header.
         params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x00\x40")
         self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 0)
         self.assertFalse(params.has_checksum)
 
         # Set multiple things.
-        params = zstd.get_frame_parameters(zstd.FRAME_HEADER + b"\x45\x40\x0f\x10\x00")
+        params = zstd.get_frame_parameters(
+            zstd.FRAME_HEADER + b"\x45\x40\x0f\x10\x00"
+        )
         self.assertEqual(params.content_size, 272)
         self.assertEqual(params.window_size, 262144)
         self.assertEqual(params.dict_id, 15)
         self.assertTrue(params.has_checksum)
 
     def test_input_types(self):
         v = zstd.FRAME_HEADER + b"\x00\x00"
 
         mutable_array = bytearray(len(v))
         mutable_array[:] = v
 
         sources = [
             memoryview(v),
             bytearray(v),
             mutable_array,
         ]
 
         for source in sources:
             params = zstd.get_frame_parameters(source)
             self.assertEqual(params.content_size, zstd.CONTENTSIZE_UNKNOWN)
             self.assertEqual(params.window_size, 1024)
             self.assertEqual(params.dict_id, 0)
             self.assertFalse(params.has_checksum)

contrib/python-zstandard/tests/test_data_structures_fuzzing.py

@@ -1,105 +1,121 b''
 import io
 import os
 import sys
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
     raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     TestCase,
 )
 
 
 s_windowlog = strategies.integers(
     min_value=zstd.WINDOWLOG_MIN, max_value=zstd.WINDOWLOG_MAX
 )
 s_chainlog = strategies.integers(
     min_value=zstd.CHAINLOG_MIN, max_value=zstd.CHAINLOG_MAX
 )
-s_hashlog = strategies.integers(min_value=zstd.HASHLOG_MIN, max_value=zstd.HASHLOG_MAX)
+s_hashlog = strategies.integers(
+    min_value=zstd.HASHLOG_MIN, max_value=zstd.HASHLOG_MAX
+)
 s_searchlog = strategies.integers(
     min_value=zstd.SEARCHLOG_MIN, max_value=zstd.SEARCHLOG_MAX
 )
 s_minmatch = strategies.integers(
     min_value=zstd.MINMATCH_MIN, max_value=zstd.MINMATCH_MAX
 )
 s_targetlength = strategies.integers(
     min_value=zstd.TARGETLENGTH_MIN, max_value=zstd.TARGETLENGTH_MAX
 )
 s_strategy = strategies.sampled_from(
     (
         zstd.STRATEGY_FAST,
         zstd.STRATEGY_DFAST,
         zstd.STRATEGY_GREEDY,
         zstd.STRATEGY_LAZY,
         zstd.STRATEGY_LAZY2,
         zstd.STRATEGY_BTLAZY2,
         zstd.STRATEGY_BTOPT,
         zstd.STRATEGY_BTULTRA,
         zstd.STRATEGY_BTULTRA2,
     )
 )
 
 
 @make_cffi
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 class TestCompressionParametersHypothesis(TestCase):
     @hypothesis.given(
         s_windowlog,
         s_chainlog,
         s_hashlog,
         s_searchlog,
         s_minmatch,
         s_targetlength,
         s_strategy,
     )
     def test_valid_init(
-        self, windowlog, chainlog, hashlog, searchlog, minmatch, targetlength, strategy
+        self,
+        windowlog,
+        chainlog,
+        hashlog,
+        searchlog,
+        minmatch,
+        targetlength,
+        strategy,
     ):
         zstd.ZstdCompressionParameters(
             window_log=windowlog,
             chain_log=chainlog,
             hash_log=hashlog,
             search_log=searchlog,
             min_match=minmatch,
             target_length=targetlength,
             strategy=strategy,
         )
 
     @hypothesis.given(
         s_windowlog,
         s_chainlog,
         s_hashlog,
         s_searchlog,
         s_minmatch,
         s_targetlength,
         s_strategy,
     )
     def test_estimated_compression_context_size(
-        self, windowlog, chainlog, hashlog, searchlog, minmatch, targetlength, strategy
+        self,
+        windowlog,
+        chainlog,
+        hashlog,
+        searchlog,
+        minmatch,
+        targetlength,
+        strategy,
     ):
         if minmatch == zstd.MINMATCH_MIN and strategy in (
             zstd.STRATEGY_FAST,
             zstd.STRATEGY_GREEDY,
         ):
             minmatch += 1
         elif minmatch == zstd.MINMATCH_MAX and strategy != zstd.STRATEGY_FAST:
             minmatch -= 1
 
         p = zstd.ZstdCompressionParameters(
             window_log=windowlog,
             chain_log=chainlog,
             hash_log=hashlog,
             search_log=searchlog,
             min_match=minmatch,
             target_length=targetlength,
             strategy=strategy,
         )
         size = p.estimated_compression_context_size()

contrib/python-zstandard/tests/test_decompressor.py

@@ -1,1670 +1,1714 b''
 import io
 import os
 import random
 import struct
 import sys
 import tempfile
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     generate_samples,
     make_cffi,
     NonClosingBytesIO,
     OpCountingBytesIO,
     TestCase,
 )
 
 
 if sys.version_info[0] >= 3:
     next = lambda it: it.__next__()
 else:
     next = lambda it: it.next()
 
 
 @make_cffi
 class TestFrameHeaderSize(TestCase):
     def test_empty(self):
         with self.assertRaisesRegex(
             zstd.ZstdError,
             "could not determine frame header size: Src size " "is incorrect",
         ):
             zstd.frame_header_size(b"")
 
     def test_too_small(self):
         with self.assertRaisesRegex(
             zstd.ZstdError,
             "could not determine frame header size: Src size " "is incorrect",
         ):
             zstd.frame_header_size(b"foob")
 
     def test_basic(self):
         # It doesn't matter that it isn't a valid frame.
         self.assertEqual(zstd.frame_header_size(b"long enough but no magic"), 6)
 
 
 @make_cffi
 class TestFrameContentSize(TestCase):
     def test_empty(self):
         with self.assertRaisesRegex(
             zstd.ZstdError, "error when determining content size"
         ):
             zstd.frame_content_size(b"")
 
     def test_too_small(self):
         with self.assertRaisesRegex(
             zstd.ZstdError, "error when determining content size"
         ):
             zstd.frame_content_size(b"foob")
 
     def test_bad_frame(self):
         with self.assertRaisesRegex(
             zstd.ZstdError, "error when determining content size"
         ):
             zstd.frame_content_size(b"invalid frame header")
 
     def test_unknown(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         frame = cctx.compress(b"foobar")
 
         self.assertEqual(zstd.frame_content_size(frame), -1)
 
     def test_empty(self):
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(b"")
 
         self.assertEqual(zstd.frame_content_size(frame), 0)
 
     def test_basic(self):
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(b"foobar")
 
         self.assertEqual(zstd.frame_content_size(frame), 6)
 
 
 @make_cffi
 class TestDecompressor(TestCase):
     def test_memory_size(self):
         dctx = zstd.ZstdDecompressor()
 
         self.assertGreater(dctx.memory_size(), 100)
 
 
 @make_cffi
 class TestDecompressor_decompress(TestCase):
     def test_empty_input(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaisesRegex(
             zstd.ZstdError, "error determining content size from frame header"
         ):
             dctx.decompress(b"")
 
     def test_invalid_input(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaisesRegex(
             zstd.ZstdError, "error determining content size from frame header"
         ):
             dctx.decompress(b"foobar")
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1)
         compressed = cctx.compress(b"foo")
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         dctx = zstd.ZstdDecompressor()
         for source in sources:
             self.assertEqual(dctx.decompress(source), b"foo")
 
     def test_no_content_size_in_frame(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaisesRegex(
             zstd.ZstdError, "could not determine content size in frame header"
         ):
             dctx.decompress(compressed)
 
     def test_content_size_present(self):
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.decompress(compressed)
         self.assertEqual(decompressed, b"foobar")
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(b"")
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.decompress(compressed)
 
         self.assertEqual(decompressed, b"")
 
     def test_max_output_size(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         source = b"foobar" * 256
         compressed = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         # Will fit into buffer exactly the size of input.
         decompressed = dctx.decompress(compressed, max_output_size=len(source))
         self.assertEqual(decompressed, source)
 
         # Input size - 1 fails
         with self.assertRaisesRegex(
             zstd.ZstdError, "decompression error: did not decompress full frame"
         ):
             dctx.decompress(compressed, max_output_size=len(source) - 1)
 
         # Input size + 1 works
-        decompressed = dctx.decompress(compressed, max_output_size=len(source) + 1)
+        decompressed = dctx.decompress(
+            compressed, max_output_size=len(source) + 1
+        )
         self.assertEqual(decompressed, source)
 
         # A much larger buffer works.
-        decompressed = dctx.decompress(compressed, max_output_size=len(source) * 64)
+        decompressed = dctx.decompress(
+            compressed, max_output_size=len(source) * 64
+        )
         self.assertEqual(decompressed, source)
 
     def test_stupidly_large_output_buffer(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         compressed = cctx.compress(b"foobar" * 256)
         dctx = zstd.ZstdDecompressor()
 
         # Will get OverflowError on some Python distributions that can't
         # handle really large integers.
         with self.assertRaises((MemoryError, OverflowError)):
             dctx.decompress(compressed, max_output_size=2 ** 62)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         orig = b"foobar" * 16384
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         compressed = cctx.compress(orig)
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         decompressed = dctx.decompress(compressed)
 
         self.assertEqual(decompressed, orig)
 
     def test_dictionary_multiple(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         sources = (b"foobar" * 8192, b"foo" * 8192, b"bar" * 8192)
         compressed = []
         cctx = zstd.ZstdCompressor(level=1, dict_data=d)
         for source in sources:
             compressed.append(cctx.compress(source))
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         for i in range(len(sources)):
             decompressed = dctx.decompress(compressed[i])
             self.assertEqual(decompressed, sources[i])
 
     def test_max_window_size(self):
         with open(__file__, "rb") as fh:
             source = fh.read()
 
         # If we write a content size, the decompressor engages single pass
         # mode and the window size doesn't come into play.
         cctx = zstd.ZstdCompressor(write_content_size=False)
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor(max_window_size=2 ** zstd.WINDOWLOG_MIN)
 
         with self.assertRaisesRegex(
-            zstd.ZstdError, "decompression error: Frame requires too much memory"
+            zstd.ZstdError,
+            "decompression error: Frame requires too much memory",
         ):
             dctx.decompress(frame, max_output_size=len(source))
 
 
 @make_cffi
 class TestDecompressor_copy_stream(TestCase):
     def test_no_read(self):
         source = object()
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaises(ValueError):
             dctx.copy_stream(source, dest)
 
     def test_no_write(self):
         source = io.BytesIO()
         dest = object()
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaises(ValueError):
             dctx.copy_stream(source, dest)
 
     def test_empty(self):
         source = io.BytesIO()
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
         # TODO should this raise an error?
         r, w = dctx.copy_stream(source, dest)
 
         self.assertEqual(r, 0)
         self.assertEqual(w, 0)
         self.assertEqual(dest.getvalue(), b"")
 
     def test_large_data(self):
         source = io.BytesIO()
         for i in range(255):
             source.write(struct.Struct(">B").pack(i) * 16384)
         source.seek(0)
 
         compressed = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         cctx.copy_stream(source, compressed)
 
         compressed.seek(0)
         dest = io.BytesIO()
         dctx = zstd.ZstdDecompressor()
         r, w = dctx.copy_stream(compressed, dest)
 
         self.assertEqual(r, len(compressed.getvalue()))
         self.assertEqual(w, len(source.getvalue()))
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b"foobarfoobar"))
+        source = OpCountingBytesIO(
+            zstd.ZstdCompressor().compress(b"foobarfoobar")
+        )
 
         dest = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         r, w = dctx.copy_stream(source, dest, read_size=1, write_size=1)
 
         self.assertEqual(r, len(source.getvalue()))
         self.assertEqual(w, len(b"foobarfoobar"))
         self.assertEqual(source._read_count, len(source.getvalue()) + 1)
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
 
 @make_cffi
 class TestDecompressor_stream_reader(TestCase):
     def test_context_manager(self):
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(b"foo") as reader:
-            with self.assertRaisesRegex(ValueError, "cannot __enter__ multiple times"):
+            with self.assertRaisesRegex(
+                ValueError, "cannot __enter__ multiple times"
+            ):
                 with reader as reader2:
                     pass
 
     def test_not_implemented(self):
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(b"foo") as reader:
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readline()
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.readlines()
 
             with self.assertRaises(io.UnsupportedOperation):
                 iter(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
                 next(reader)
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.write(b"foo")
 
             with self.assertRaises(io.UnsupportedOperation):
                 reader.writelines([])
 
     def test_constant_methods(self):
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(b"foo") as reader:
             self.assertFalse(reader.closed)
             self.assertTrue(reader.readable())
             self.assertFalse(reader.writable())
             self.assertTrue(reader.seekable())
             self.assertFalse(reader.isatty())
             self.assertFalse(reader.closed)
             self.assertIsNone(reader.flush())
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_closed(self):
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(b"foo") as reader:
             reader.close()
             self.assertTrue(reader.closed)
             with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(1)
 
     def test_read_sizes(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(foo) as reader:
             with self.assertRaisesRegex(
                 ValueError, "cannot read negative amounts less than -1"
             ):
                 reader.read(-2)
 
             self.assertEqual(reader.read(0), b"")
             self.assertEqual(reader.read(), b"foo")
 
     def test_read_buffer(self):
         cctx = zstd.ZstdCompressor()
 
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             self.assertEqual(reader.tell(), 0)
 
             # We should get entire frame in one read.
             result = reader.read(8192)
             self.assertEqual(result, source)
             self.assertEqual(reader.tell(), len(source))
 
             # Read after EOF should return empty bytes.
             self.assertEqual(reader.read(1), b"")
             self.assertEqual(reader.tell(), len(result))
 
         self.assertTrue(reader.closed)
 
     def test_read_buffer_small_chunks(self):
         cctx = zstd.ZstdCompressor()
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(frame, read_size=1) as reader:
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
         self.assertEqual(b"".join(chunks), source)
 
     def test_read_stream(self):
         cctx = zstd.ZstdCompressor()
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_reader(io.BytesIO(frame)) as reader:
             self.assertEqual(reader.tell(), 0)
 
             chunk = reader.read(8192)
             self.assertEqual(chunk, source)
             self.assertEqual(reader.tell(), len(source))
             self.assertEqual(reader.read(1), b"")
             self.assertEqual(reader.tell(), len(source))
             self.assertFalse(reader.closed)
 
         self.assertTrue(reader.closed)
 
     def test_read_stream_small_chunks(self):
         cctx = zstd.ZstdCompressor()
         source = b"".join([b"foo" * 60, b"bar" * 60, b"baz" * 60])
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(io.BytesIO(frame), read_size=1) as reader:
             while True:
                 chunk = reader.read(1)
                 if not chunk:
                     break
 
                 chunks.append(chunk)
                 self.assertEqual(reader.tell(), sum(map(len, chunks)))
 
         self.assertEqual(b"".join(chunks), source)
 
     def test_read_after_exit(self):
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(b"foo" * 60)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             while reader.read(16):
                 pass
 
         self.assertTrue(reader.closed)
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(10)
 
     def test_illegal_seeks(self):
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(b"foo" * 60)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
-            with self.assertRaisesRegex(ValueError, "cannot seek to negative position"):
+            with self.assertRaisesRegex(
+                ValueError, "cannot seek to negative position"
+            ):
                 reader.seek(-1, os.SEEK_SET)
 
             reader.read(1)
 
             with self.assertRaisesRegex(
                 ValueError, "cannot seek zstd decompression stream backwards"
             ):
                 reader.seek(0, os.SEEK_SET)
 
             with self.assertRaisesRegex(
                 ValueError, "cannot seek zstd decompression stream backwards"
             ):
                 reader.seek(-1, os.SEEK_CUR)
 
             with self.assertRaisesRegex(
-                ValueError, "zstd decompression streams cannot be seeked with SEEK_END"
+                ValueError,
+                "zstd decompression streams cannot be seeked with SEEK_END",
             ):
                 reader.seek(0, os.SEEK_END)
 
             reader.close()
 
             with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.seek(4, os.SEEK_SET)
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.seek(0)
 
     def test_seek(self):
         source = b"foobar" * 60
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame) as reader:
             reader.seek(3)
             self.assertEqual(reader.read(3), b"bar")
 
             reader.seek(4, os.SEEK_CUR)
             self.assertEqual(reader.read(2), b"ar")
 
     def test_no_context_manager(self):
         source = b"foobar" * 60
         cctx = zstd.ZstdCompressor()
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(frame)
 
         self.assertEqual(reader.read(6), b"foobar")
         self.assertEqual(reader.read(18), b"foobar" * 3)
         self.assertFalse(reader.closed)
 
         # Calling close prevents subsequent use.
         reader.close()
         self.assertTrue(reader.closed)
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             reader.read(6)
 
     def test_read_after_error(self):
         source = io.BytesIO(b"")
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(source)
 
         with reader:
             reader.read(0)
 
         with reader:
             with self.assertRaisesRegex(ValueError, "stream is closed"):
                 reader.read(100)
 
     def test_partial_read(self):
         # Inspired by https://github.com/indygreg/python-zstandard/issues/71.
         buffer = io.BytesIO()
         cctx = zstd.ZstdCompressor()
         writer = cctx.stream_writer(buffer)
         writer.write(bytearray(os.urandom(1000000)))
         writer.flush(zstd.FLUSH_FRAME)
         buffer.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(buffer)
 
         while True:
             chunk = reader.read(8192)
             if not chunk:
                 break
 
     def test_read_multiple_frames(self):
         cctx = zstd.ZstdCompressor()
         source = io.BytesIO()
         writer = cctx.stream_writer(source)
         writer.write(b"foo")
         writer.flush(zstd.FLUSH_FRAME)
         writer.write(b"bar")
         writer.flush(zstd.FLUSH_FRAME)
 
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(source.getvalue())
         self.assertEqual(reader.read(2), b"fo")
         self.assertEqual(reader.read(2), b"o")
         self.assertEqual(reader.read(2), b"ba")
         self.assertEqual(reader.read(2), b"r")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
         self.assertEqual(reader.read(2), b"fo")
         self.assertEqual(reader.read(2), b"o")
         self.assertEqual(reader.read(2), b"ba")
         self.assertEqual(reader.read(2), b"r")
 
         reader = dctx.stream_reader(source.getvalue())
         self.assertEqual(reader.read(3), b"foo")
         self.assertEqual(reader.read(3), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
         self.assertEqual(reader.read(3), b"foo")
         self.assertEqual(reader.read(3), b"bar")
 
         reader = dctx.stream_reader(source.getvalue())
         self.assertEqual(reader.read(4), b"foo")
         self.assertEqual(reader.read(4), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
         self.assertEqual(reader.read(4), b"foo")
         self.assertEqual(reader.read(4), b"bar")
 
         reader = dctx.stream_reader(source.getvalue())
         self.assertEqual(reader.read(128), b"foo")
         self.assertEqual(reader.read(128), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source)
         self.assertEqual(reader.read(128), b"foo")
         self.assertEqual(reader.read(128), b"bar")
 
         # Now tests for reads spanning frames.
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
         self.assertEqual(reader.read(3), b"foo")
         self.assertEqual(reader.read(3), b"bar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
         self.assertEqual(reader.read(3), b"foo")
         self.assertEqual(reader.read(3), b"bar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
         self.assertEqual(reader.read(6), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
         self.assertEqual(reader.read(6), b"foobar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
         self.assertEqual(reader.read(7), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
         self.assertEqual(reader.read(7), b"foobar")
 
         reader = dctx.stream_reader(source.getvalue(), read_across_frames=True)
         self.assertEqual(reader.read(128), b"foobar")
 
         source.seek(0)
         reader = dctx.stream_reader(source, read_across_frames=True)
         self.assertEqual(reader.read(128), b"foobar")
 
     def test_readinto(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         # Attempting to readinto() a non-writable buffer fails.
         # The exact exception varies based on the backend.
         reader = dctx.stream_reader(foo)
         with self.assertRaises(Exception):
             reader.readinto(b"foobar")
 
         # readinto() with sufficiently large destination.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto(b), 3)
         self.assertEqual(b[0:3], b"foo")
         self.assertEqual(reader.readinto(b), 0)
         self.assertEqual(b[0:3], b"foo")
 
         # readinto() with small reads.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo, read_size=1)
         self.assertEqual(reader.readinto(b), 3)
         self.assertEqual(b[0:3], b"foo")
 
         # Too small destination buffer.
         b = bytearray(2)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto(b), 2)
         self.assertEqual(b[:], b"fo")
 
     def test_readinto1(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         reader = dctx.stream_reader(foo)
         with self.assertRaises(Exception):
             reader.readinto1(b"foobar")
 
         # Sufficiently large destination.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto1(b), 3)
         self.assertEqual(b[0:3], b"foo")
         self.assertEqual(reader.readinto1(b), 0)
         self.assertEqual(b[0:3], b"foo")
 
         # readinto() with small reads.
         b = bytearray(1024)
         reader = dctx.stream_reader(foo, read_size=1)
         self.assertEqual(reader.readinto1(b), 3)
         self.assertEqual(b[0:3], b"foo")
 
         # Too small destination buffer.
         b = bytearray(2)
         reader = dctx.stream_reader(foo)
         self.assertEqual(reader.readinto1(b), 2)
         self.assertEqual(b[:], b"fo")
 
     def test_readall(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(foo)
 
         self.assertEqual(reader.readall(), b"foo")
 
     def test_read1(self):
         cctx = zstd.ZstdCompressor()
         foo = cctx.compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         b = OpCountingBytesIO(foo)
         reader = dctx.stream_reader(b)
 
         self.assertEqual(reader.read1(), b"foo")
         self.assertEqual(b._read_count, 1)
 
         b = OpCountingBytesIO(foo)
         reader = dctx.stream_reader(b)
 
         self.assertEqual(reader.read1(0), b"")
         self.assertEqual(reader.read1(2), b"fo")
         self.assertEqual(b._read_count, 1)
         self.assertEqual(reader.read1(1), b"o")
         self.assertEqual(b._read_count, 1)
         self.assertEqual(reader.read1(1), b"")
         self.assertEqual(b._read_count, 2)
 
     def test_read_lines(self):
         cctx = zstd.ZstdCompressor()
-        source = b"\n".join(("line %d" % i).encode("ascii") for i in range(1024))
+        source = b"\n".join(
+            ("line %d" % i).encode("ascii") for i in range(1024)
+        )
 
         frame = cctx.compress(source)
 
         dctx = zstd.ZstdDecompressor()
         reader = dctx.stream_reader(frame)
         tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = []
         for line in tr:
             lines.append(line.encode("utf-8"))
 
         self.assertEqual(len(lines), 1024)
         self.assertEqual(b"".join(lines), source)
 
         reader = dctx.stream_reader(frame)
         tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = tr.readlines()
         self.assertEqual(len(lines), 1024)
         self.assertEqual("".join(lines).encode("utf-8"), source)
 
         reader = dctx.stream_reader(frame)
         tr = io.TextIOWrapper(reader, encoding="utf-8")
 
         lines = []
         while True:
             line = tr.readline()
             if not line:
                 break
 
             lines.append(line.encode("utf-8"))
 
         self.assertEqual(len(lines), 1024)
         self.assertEqual(b"".join(lines), source)
 
 
 @make_cffi
 class TestDecompressor_decompressobj(TestCase):
     def test_simple(self):
         data = zstd.ZstdCompressor(level=1).compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
         self.assertEqual(dobj.decompress(data), b"foobar")
         self.assertIsNone(dobj.flush())
         self.assertIsNone(dobj.flush(10))
         self.assertIsNone(dobj.flush(length=100))
 
     def test_input_types(self):
         compressed = zstd.ZstdCompressor(level=1).compress(b"foo")
 
         dctx = zstd.ZstdDecompressor()
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         for source in sources:
             dobj = dctx.decompressobj()
             self.assertIsNone(dobj.flush())
             self.assertIsNone(dobj.flush(10))
             self.assertIsNone(dobj.flush(length=100))
             self.assertEqual(dobj.decompress(source), b"foo")
             self.assertIsNone(dobj.flush())
 
     def test_reuse(self):
         data = zstd.ZstdCompressor(level=1).compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
         dobj.decompress(data)
 
-        with self.assertRaisesRegex(zstd.ZstdError, "cannot use a decompressobj"):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "cannot use a decompressobj"
+        ):
             dobj.decompress(data)
             self.assertIsNone(dobj.flush())
 
     def test_bad_write_size(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaisesRegex(ValueError, "write_size must be positive"):
             dctx.decompressobj(write_size=0)
 
     def test_write_size(self):
         source = b"foo" * 64 + b"bar" * 128
         data = zstd.ZstdCompressor(level=1).compress(source)
 
         dctx = zstd.ZstdDecompressor()
 
         for i in range(128):
             dobj = dctx.decompressobj(write_size=i + 1)
             self.assertEqual(dobj.decompress(data), source)
 
 
 def decompress_via_writer(data):
     buffer = io.BytesIO()
     dctx = zstd.ZstdDecompressor()
     decompressor = dctx.stream_writer(buffer)
     decompressor.write(data)
 
     return buffer.getvalue()
 
 
 @make_cffi
 class TestDecompressor_stream_writer(TestCase):
     def test_io_api(self):
         buffer = io.BytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         self.assertFalse(writer.closed)
         self.assertFalse(writer.isatty())
         self.assertFalse(writer.readable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readline(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readlines(hint=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(0)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.seek(10, os.SEEK_SET)
 
         self.assertFalse(writer.seekable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.tell()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.truncate(size=42)
 
         self.assertTrue(writer.writable())
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.writelines([])
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.read(size=42)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readall()
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.readinto(None)
 
         with self.assertRaises(io.UnsupportedOperation):
             writer.fileno()
 
     def test_fileno_file(self):
         with tempfile.TemporaryFile("wb") as tf:
             dctx = zstd.ZstdDecompressor()
             writer = dctx.stream_writer(tf)
 
             self.assertEqual(writer.fileno(), tf.fileno())
 
     def test_close(self):
         foo = zstd.ZstdCompressor().compress(b"foo")
 
         buffer = NonClosingBytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         writer.write(foo)
         self.assertFalse(writer.closed)
         self.assertFalse(buffer.closed)
         writer.close()
         self.assertTrue(writer.closed)
         self.assertTrue(buffer.closed)
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.write(b"")
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             writer.flush()
 
         with self.assertRaisesRegex(ValueError, "stream is closed"):
             with writer:
                 pass
 
         self.assertEqual(buffer.getvalue(), b"foo")
 
         # Context manager exit should close stream.
         buffer = NonClosingBytesIO()
         writer = dctx.stream_writer(buffer)
 
         with writer:
             writer.write(foo)
 
         self.assertTrue(writer.closed)
         self.assertEqual(buffer.getvalue(), b"foo")
 
     def test_flush(self):
         buffer = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         writer = dctx.stream_writer(buffer)
 
         writer.flush()
         self.assertEqual(buffer._flush_count, 1)
         writer.flush()
         self.assertEqual(buffer._flush_count, 2)
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor()
         empty = cctx.compress(b"")
         self.assertEqual(decompress_via_writer(empty), b"")
 
     def test_input_types(self):
         cctx = zstd.ZstdCompressor(level=1)
         compressed = cctx.compress(b"foo")
 
         mutable_array = bytearray(len(compressed))
         mutable_array[:] = compressed
 
         sources = [
             memoryview(compressed),
             bytearray(compressed),
             mutable_array,
         ]
 
         dctx = zstd.ZstdDecompressor()
         for source in sources:
             buffer = io.BytesIO()
 
             decompressor = dctx.stream_writer(buffer)
             decompressor.write(source)
             self.assertEqual(buffer.getvalue(), b"foo")
 
             buffer = NonClosingBytesIO()
 
             with dctx.stream_writer(buffer) as decompressor:
                 self.assertEqual(decompressor.write(source), 3)
 
             self.assertEqual(buffer.getvalue(), b"foo")
 
             buffer = io.BytesIO()
             writer = dctx.stream_writer(buffer, write_return_read=True)
             self.assertEqual(writer.write(source), len(source))
             self.assertEqual(buffer.getvalue(), b"foo")
 
     def test_large_roundtrip(self):
         chunks = []
         for i in range(255):
             chunks.append(struct.Struct(">B").pack(i) * 16384)
         orig = b"".join(chunks)
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(orig)
 
         self.assertEqual(decompress_via_writer(compressed), orig)
 
     def test_multiple_calls(self):
         chunks = []
         for i in range(255):
             for j in range(255):
                 chunks.append(struct.Struct(">B").pack(j) * i)
 
         orig = b"".join(chunks)
         cctx = zstd.ZstdCompressor()
         compressed = cctx.compress(orig)
 
         buffer = NonClosingBytesIO()
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_writer(buffer) as decompressor:
             pos = 0
             while pos < len(compressed):
                 pos2 = pos + 8192
                 decompressor.write(compressed[pos:pos2])
                 pos += 8192
         self.assertEqual(buffer.getvalue(), orig)
 
         # Again with write_return_read=True
         buffer = io.BytesIO()
         writer = dctx.stream_writer(buffer, write_return_read=True)
         pos = 0
         while pos < len(compressed):
             pos2 = pos + 8192
             chunk = compressed[pos:pos2]
             self.assertEqual(writer.write(chunk), len(chunk))
             pos += 8192
         self.assertEqual(buffer.getvalue(), orig)
 
     def test_dictionary(self):
         samples = []
         for i in range(128):
             samples.append(b"foo" * 64)
             samples.append(b"bar" * 64)
             samples.append(b"foobar" * 64)
 
         d = zstd.train_dictionary(8192, samples)
 
         orig = b"foobar" * 16384
         buffer = NonClosingBytesIO()
         cctx = zstd.ZstdCompressor(dict_data=d)
         with cctx.stream_writer(buffer) as compressor:
             self.assertEqual(compressor.write(orig), 0)
 
         compressed = buffer.getvalue()
         buffer = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
         decompressor = dctx.stream_writer(buffer)
         self.assertEqual(decompressor.write(compressed), len(orig))
         self.assertEqual(buffer.getvalue(), orig)
 
         buffer = NonClosingBytesIO()
 
         with dctx.stream_writer(buffer) as decompressor:
             self.assertEqual(decompressor.write(compressed), len(orig))
 
         self.assertEqual(buffer.getvalue(), orig)
 
     def test_memory_size(self):
         dctx = zstd.ZstdDecompressor()
         buffer = io.BytesIO()
 
         decompressor = dctx.stream_writer(buffer)
         size = decompressor.memory_size()
         self.assertGreater(size, 100000)
 
         with dctx.stream_writer(buffer) as decompressor:
             size = decompressor.memory_size()
 
         self.assertGreater(size, 100000)
 
     def test_write_size(self):
         source = zstd.ZstdCompressor().compress(b"foobarfoobar")
         dest = OpCountingBytesIO()
         dctx = zstd.ZstdDecompressor()
         with dctx.stream_writer(dest, write_size=1) as decompressor:
             s = struct.Struct(">B")
             for c in source:
                 if not isinstance(c, str):
                     c = s.pack(c)
                 decompressor.write(c)
 
         self.assertEqual(dest.getvalue(), b"foobarfoobar")
         self.assertEqual(dest._write_count, len(dest.getvalue()))
 
 
 @make_cffi
 class TestDecompressor_read_to_iter(TestCase):
     def test_type_validation(self):
         dctx = zstd.ZstdDecompressor()
 
         # Object with read() works.
         dctx.read_to_iter(io.BytesIO())
 
         # Buffer protocol works.
         dctx.read_to_iter(b"foobar")
 
-        with self.assertRaisesRegex(ValueError, "must pass an object with a read"):
+        with self.assertRaisesRegex(
+            ValueError, "must pass an object with a read"
+        ):
             b"".join(dctx.read_to_iter(True))
 
     def test_empty_input(self):
         dctx = zstd.ZstdDecompressor()
 
         source = io.BytesIO()
         it = dctx.read_to_iter(source)
         # TODO this is arguably wrong. Should get an error about missing frame foo.
         with self.assertRaises(StopIteration):
             next(it)
 
         it = dctx.read_to_iter(b"")
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_invalid_input(self):
         dctx = zstd.ZstdDecompressor()
 
         source = io.BytesIO(b"foobar")
         it = dctx.read_to_iter(source)
         with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
             next(it)
 
         it = dctx.read_to_iter(b"foobar")
         with self.assertRaisesRegex(zstd.ZstdError, "Unknown frame descriptor"):
             next(it)
 
     def test_empty_roundtrip(self):
         cctx = zstd.ZstdCompressor(level=1, write_content_size=False)
         empty = cctx.compress(b"")
 
         source = io.BytesIO(empty)
         source.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(source)
 
         # No chunks should be emitted since there is no data.
         with self.assertRaises(StopIteration):
             next(it)
 
         # Again for good measure.
         with self.assertRaises(StopIteration):
             next(it)
 
     def test_skip_bytes_too_large(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaisesRegex(
             ValueError, "skip_bytes must be smaller than read_size"
         ):
             b"".join(dctx.read_to_iter(b"", skip_bytes=1, read_size=1))
 
         with self.assertRaisesRegex(
             ValueError, "skip_bytes larger than first input chunk"
         ):
             b"".join(dctx.read_to_iter(b"foobar", skip_bytes=10))
 
     def test_skip_bytes(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         compressed = cctx.compress(b"foobar")
 
         dctx = zstd.ZstdDecompressor()
         output = b"".join(dctx.read_to_iter(b"hdr" + compressed, skip_bytes=3))
         self.assertEqual(output, b"foobar")
 
     def test_large_output(self):
         source = io.BytesIO()
         source.write(b"f" * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE)
         source.write(b"o")
         source.seek(0)
 
         cctx = zstd.ZstdCompressor(level=1)
         compressed = io.BytesIO(cctx.compress(source.getvalue()))
         compressed.seek(0)
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(compressed)
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         decompressed = b"".join(chunks)
         self.assertEqual(decompressed, source.getvalue())
 
         # And again with buffer protocol.
         it = dctx.read_to_iter(compressed.getvalue())
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         decompressed = b"".join(chunks)
         self.assertEqual(decompressed, source.getvalue())
 
-    @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
+    @unittest.skipUnless(
+        "ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set"
+    )
     def test_large_input(self):
         bytes = list(struct.Struct(">B").pack(i) for i in range(256))
         compressed = NonClosingBytesIO()
         input_size = 0
         cctx = zstd.ZstdCompressor(level=1)
         with cctx.stream_writer(compressed) as compressor:
             while True:
                 compressor.write(random.choice(bytes))
                 input_size += 1
 
                 have_compressed = (
                     len(compressed.getvalue())
                     > zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
                 )
-                have_raw = input_size > zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE * 2
+                have_raw = (
+                    input_size > zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE * 2
+                )
                 if have_compressed and have_raw:
                     break
 
         compressed = io.BytesIO(compressed.getvalue())
         self.assertGreater(
-            len(compressed.getvalue()), zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE
+            len(compressed.getvalue()),
+            zstd.DECOMPRESSION_RECOMMENDED_INPUT_SIZE,
         )
 
         dctx = zstd.ZstdDecompressor()
         it = dctx.read_to_iter(compressed)
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         decompressed = b"".join(chunks)
         self.assertEqual(len(decompressed), input_size)
 
         # And again with buffer protocol.
         it = dctx.read_to_iter(compressed.getvalue())
 
         chunks = []
         chunks.append(next(it))
         chunks.append(next(it))
         chunks.append(next(it))
 
         with self.assertRaises(StopIteration):
             next(it)
 
         decompressed = b"".join(chunks)
         self.assertEqual(len(decompressed), input_size)
 
     def test_interesting(self):
         # Found this edge case via fuzzing.
         cctx = zstd.ZstdCompressor(level=1)
 
         source = io.BytesIO()
 
         compressed = NonClosingBytesIO()
         with cctx.stream_writer(compressed) as compressor:
             for i in range(256):
                 chunk = b"\0" * 1024
                 compressor.write(chunk)
                 source.write(chunk)
 
         dctx = zstd.ZstdDecompressor()
 
         simple = dctx.decompress(
             compressed.getvalue(), max_output_size=len(source.getvalue())
         )
         self.assertEqual(simple, source.getvalue())
 
         compressed = io.BytesIO(compressed.getvalue())
         streamed = b"".join(dctx.read_to_iter(compressed))
         self.assertEqual(streamed, source.getvalue())
 
     def test_read_write_size(self):
-        source = OpCountingBytesIO(zstd.ZstdCompressor().compress(b"foobarfoobar"))
+        source = OpCountingBytesIO(
+            zstd.ZstdCompressor().compress(b"foobarfoobar")
+        )
         dctx = zstd.ZstdDecompressor()
         for chunk in dctx.read_to_iter(source, read_size=1, write_size=1):
             self.assertEqual(len(chunk), 1)
 
         self.assertEqual(source._read_count, len(source.getvalue()))
 
     def test_magic_less(self):
         params = zstd.CompressionParameters.from_level(
             1, format=zstd.FORMAT_ZSTD1_MAGICLESS
         )
         cctx = zstd.ZstdCompressor(compression_params=params)
         frame = cctx.compress(b"foobar")
 
         self.assertNotEqual(frame[0:4], b"\x28\xb5\x2f\xfd")
 
         dctx = zstd.ZstdDecompressor()
         with self.assertRaisesRegex(
             zstd.ZstdError, "error determining content size from frame header"
         ):
             dctx.decompress(frame)
 
         dctx = zstd.ZstdDecompressor(format=zstd.FORMAT_ZSTD1_MAGICLESS)
         res = b"".join(dctx.read_to_iter(frame))
         self.assertEqual(res, b"foobar")
 
 
 @make_cffi
 class TestDecompressor_content_dict_chain(TestCase):
     def test_bad_inputs_simple(self):
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaises(TypeError):
             dctx.decompress_content_dict_chain(b"foo")
 
         with self.assertRaises(TypeError):
             dctx.decompress_content_dict_chain((b"foo", b"bar"))
 
         with self.assertRaisesRegex(ValueError, "empty input chain"):
             dctx.decompress_content_dict_chain([])
 
         with self.assertRaisesRegex(ValueError, "chunk 0 must be bytes"):
             dctx.decompress_content_dict_chain([u"foo"])
 
         with self.assertRaisesRegex(ValueError, "chunk 0 must be bytes"):
             dctx.decompress_content_dict_chain([True])
 
         with self.assertRaisesRegex(
             ValueError, "chunk 0 is too small to contain a zstd frame"
         ):
             dctx.decompress_content_dict_chain([zstd.FRAME_HEADER])
 
-        with self.assertRaisesRegex(ValueError, "chunk 0 is not a valid zstd frame"):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 0 is not a valid zstd frame"
+        ):
             dctx.decompress_content_dict_chain([b"foo" * 8])
 
-        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b"foo" * 64)
+        no_size = zstd.ZstdCompressor(write_content_size=False).compress(
+            b"foo" * 64
+        )
 
         with self.assertRaisesRegex(
             ValueError, "chunk 0 missing content size in frame"
         ):
             dctx.decompress_content_dict_chain([no_size])
 
         # Corrupt first frame.
         frame = zstd.ZstdCompressor().compress(b"foo" * 64)
         frame = frame[0:12] + frame[15:]
         with self.assertRaisesRegex(
             zstd.ZstdError, "chunk 0 did not decompress full frame"
         ):
             dctx.decompress_content_dict_chain([frame])
 
     def test_bad_subsequent_input(self):
         initial = zstd.ZstdCompressor().compress(b"foo" * 64)
 
         dctx = zstd.ZstdDecompressor()
 
         with self.assertRaisesRegex(ValueError, "chunk 1 must be bytes"):
             dctx.decompress_content_dict_chain([initial, u"foo"])
 
         with self.assertRaisesRegex(ValueError, "chunk 1 must be bytes"):
             dctx.decompress_content_dict_chain([initial, None])
 
         with self.assertRaisesRegex(
             ValueError, "chunk 1 is too small to contain a zstd frame"
         ):
             dctx.decompress_content_dict_chain([initial, zstd.FRAME_HEADER])
 
-        with self.assertRaisesRegex(ValueError, "chunk 1 is not a valid zstd frame"):
+        with self.assertRaisesRegex(
+            ValueError, "chunk 1 is not a valid zstd frame"
+        ):
             dctx.decompress_content_dict_chain([initial, b"foo" * 8])
 
-        no_size = zstd.ZstdCompressor(write_content_size=False).compress(b"foo" * 64)
+        no_size = zstd.ZstdCompressor(write_content_size=False).compress(
+            b"foo" * 64
+        )
 
         with self.assertRaisesRegex(
             ValueError, "chunk 1 missing content size in frame"
         ):
             dctx.decompress_content_dict_chain([initial, no_size])
 
         # Corrupt second frame.
-        cctx = zstd.ZstdCompressor(dict_data=zstd.ZstdCompressionDict(b"foo" * 64))
+        cctx = zstd.ZstdCompressor(
+            dict_data=zstd.ZstdCompressionDict(b"foo" * 64)
+        )
         frame = cctx.compress(b"bar" * 64)
         frame = frame[0:12] + frame[15:]
 
         with self.assertRaisesRegex(
             zstd.ZstdError, "chunk 1 did not decompress full frame"
         ):
             dctx.decompress_content_dict_chain([initial, frame])
 
     def test_simple(self):
         original = [
             b"foo" * 64,
             b"foobar" * 64,
             b"baz" * 64,
             b"foobaz" * 64,
             b"foobarbaz" * 64,
         ]
 
         chunks = []
         chunks.append(zstd.ZstdCompressor().compress(original[0]))
         for i, chunk in enumerate(original[1:]):
             d = zstd.ZstdCompressionDict(original[i])
             cctx = zstd.ZstdCompressor(dict_data=d)
             chunks.append(cctx.compress(chunk))
 
         for i in range(1, len(original)):
             chain = chunks[0:i]
             expected = original[i - 1]
             dctx = zstd.ZstdDecompressor()
             decompressed = dctx.decompress_content_dict_chain(chain)
             self.assertEqual(decompressed, expected)
 
 
 # TODO enable for CFFI
 class TestDecompressor_multi_decompress_to_buffer(TestCase):
     def test_invalid_inputs(self):
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         with self.assertRaises(TypeError):
             dctx.multi_decompress_to_buffer(True)
 
         with self.assertRaises(TypeError):
             dctx.multi_decompress_to_buffer((1, 2))
 
-        with self.assertRaisesRegex(TypeError, "item 0 not a bytes like object"):
+        with self.assertRaisesRegex(
+            TypeError, "item 0 not a bytes like object"
+        ):
             dctx.multi_decompress_to_buffer([u"foo"])
 
         with self.assertRaisesRegex(
             ValueError, "could not determine decompressed size of item 0"
         ):
             dctx.multi_decompress_to_buffer([b"foobarbaz"])
 
     def test_list_input(self):
         cctx = zstd.ZstdCompressor()
 
         original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(d) for d in original]
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
         self.assertEqual(result[0].offset, 0)
         self.assertEqual(len(result[0]), 12)
         self.assertEqual(result[1].offset, 12)
         self.assertEqual(len(result[1]), 18)
 
     def test_list_input_frame_sizes(self):
         cctx = zstd.ZstdCompressor()
 
         original = [b"foo" * 4, b"bar" * 6, b"baz" * 8]
         frames = [cctx.compress(d) for d in original]
         sizes = struct.pack("=" + "Q" * len(original), *map(len, original))
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
-        result = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes)
+        result = dctx.multi_decompress_to_buffer(
+            frames, decompressed_sizes=sizes
+        )
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
     def test_buffer_with_segments_input(self):
         cctx = zstd.ZstdCompressor()
 
         original = [b"foo" * 4, b"bar" * 6]
         frames = [cctx.compress(d) for d in original]
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         segments = struct.pack(
             "=QQQQ", 0, len(frames[0]), len(frames[0]), len(frames[1])
         )
         b = zstd.BufferWithSegments(b"".join(frames), segments)
 
         result = dctx.multi_decompress_to_buffer(b)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result[0].offset, 0)
         self.assertEqual(len(result[0]), 12)
         self.assertEqual(result[1].offset, 12)
         self.assertEqual(len(result[1]), 18)
 
     def test_buffer_with_segments_sizes(self):
         cctx = zstd.ZstdCompressor(write_content_size=False)
         original = [b"foo" * 4, b"bar" * 6, b"baz" * 8]
         frames = [cctx.compress(d) for d in original]
         sizes = struct.pack("=" + "Q" * len(original), *map(len, original))
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         segments = struct.pack(
             "=QQQQQQ",
             0,
             len(frames[0]),
             len(frames[0]),
             len(frames[1]),
             len(frames[0]) + len(frames[1]),
             len(frames[2]),
         )
         b = zstd.BufferWithSegments(b"".join(frames), segments)
 
         result = dctx.multi_decompress_to_buffer(b, decompressed_sizes=sizes)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), sum(map(len, original)))
 
         for i, data in enumerate(original):
             self.assertEqual(result[i].tobytes(), data)
 
     def test_buffer_with_segments_collection_input(self):
         cctx = zstd.ZstdCompressor()
 
         original = [
             b"foo0" * 2,
             b"foo1" * 3,
             b"foo2" * 4,
             b"foo3" * 5,
             b"foo4" * 6,
         ]
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         frames = cctx.multi_compress_to_buffer(original)
 
         # Check round trip.
         dctx = zstd.ZstdDecompressor()
 
         decompressed = dctx.multi_decompress_to_buffer(frames, threads=3)
 
         self.assertEqual(len(decompressed), len(original))
 
         for i, data in enumerate(original):
             self.assertEqual(data, decompressed[i].tobytes())
 
         # And a manual mode.
         b = b"".join([frames[0].tobytes(), frames[1].tobytes()])
         b1 = zstd.BufferWithSegments(
-            b, struct.pack("=QQQQ", 0, len(frames[0]), len(frames[0]), len(frames[1]))
+            b,
+            struct.pack(
+                "=QQQQ", 0, len(frames[0]), len(frames[0]), len(frames[1])
+            ),
         )
 
-        b = b"".join([frames[2].tobytes(), frames[3].tobytes(), frames[4].tobytes()])
+        b = b"".join(
+            [frames[2].tobytes(), frames[3].tobytes(), frames[4].tobytes()]
+        )
         b2 = zstd.BufferWithSegments(
             b,
             struct.pack(
                 "=QQQQQQ",
                 0,
                 len(frames[2]),
                 len(frames[2]),
                 len(frames[3]),
                 len(frames[2]) + len(frames[3]),
                 len(frames[4]),
             ),
         )
 
         c = zstd.BufferWithSegmentsCollection(b1, b2)
 
         dctx = zstd.ZstdDecompressor()
         decompressed = dctx.multi_decompress_to_buffer(c)
 
         self.assertEqual(len(decompressed), 5)
         for i in range(5):
             self.assertEqual(decompressed[i].tobytes(), original[i])
 
     def test_dict(self):
         d = zstd.train_dictionary(16384, generate_samples(), k=64, d=16)
 
         cctx = zstd.ZstdCompressor(dict_data=d, level=1)
         frames = [cctx.compress(s) for s in generate_samples()]
 
         dctx = zstd.ZstdDecompressor(dict_data=d)
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames)
 
         self.assertEqual([o.tobytes() for o in result], generate_samples())
 
     def test_multiple_threads(self):
         cctx = zstd.ZstdCompressor()
 
         frames = []
         frames.extend(cctx.compress(b"x" * 64) for i in range(256))
         frames.extend(cctx.compress(b"y" * 64) for i in range(256))
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         result = dctx.multi_decompress_to_buffer(frames, threads=-1)
 
         self.assertEqual(len(result), len(frames))
         self.assertEqual(result.size(), 2 * 64 * 256)
         self.assertEqual(result[0].tobytes(), b"x" * 64)
         self.assertEqual(result[256].tobytes(), b"y" * 64)
 
     def test_item_failure(self):
         cctx = zstd.ZstdCompressor()
         frames = [cctx.compress(b"x" * 128), cctx.compress(b"y" * 128)]
 
         frames[1] = frames[1][0:15] + b"extra" + frames[1][15:]
 
         dctx = zstd.ZstdDecompressor()
 
         if not hasattr(dctx, "multi_decompress_to_buffer"):
             self.skipTest("multi_decompress_to_buffer not available")
 
         with self.assertRaisesRegex(
             zstd.ZstdError,
             "error decompressing item 1: ("
             "Corrupted block|"
             "Destination buffer is too small)",
         ):
             dctx.multi_decompress_to_buffer(frames)
 
         with self.assertRaisesRegex(
             zstd.ZstdError,
             "error decompressing item 1: ("
             "Corrupted block|"
             "Destination buffer is too small)",
         ):
             dctx.multi_decompress_to_buffer(frames, threads=2)

contrib/python-zstandard/tests/test_decompressor_fuzzing.py

@@ -1,576 +1,593 b''
 import io
 import os
 import unittest
 
 try:
     import hypothesis
     import hypothesis.strategies as strategies
 except ImportError:
     raise unittest.SkipTest("hypothesis not available")
 
 import zstandard as zstd
 
 from .common import (
     make_cffi,
     NonClosingBytesIO,
     random_input_data,
     TestCase,
 )
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestDecompressor_stream_reader_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_sizes=strategies.data(),
     )
     def test_stream_source_read_variance(
         self, original, level, streaming, source_read_size, read_sizes
     ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), original)
 
     # Similar to above except we have a constant read() size.
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_size=strategies.integers(-1, 131072),
     )
     def test_stream_source_read_size(
         self, original, level, streaming, source_read_size, read_size
     ):
         if read_size == 0:
             read_size = 1
 
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         reader = dctx.stream_reader(source, read_size=source_read_size)
         while True:
             chunk = reader.read(read_size)
             if not chunk and read_size:
                 break
 
             chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_sizes=strategies.data(),
     )
     def test_buffer_source_read_variance(
         self, original, level, streaming, source_read_size, read_sizes
     ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             frame = source.getvalue()
         else:
             frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         with dctx.stream_reader(frame, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), original)
 
     # Similar to above except we have a constant read() size.
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_size=strategies.integers(-1, 131072),
     )
     def test_buffer_source_constant_read_size(
         self, original, level, streaming, source_read_size, read_size
     ):
         if read_size == 0:
             read_size = -1
 
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             frame = source.getvalue()
         else:
             frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         chunks = []
 
         reader = dctx.stream_reader(frame, read_size=source_read_size)
         while True:
             chunk = reader.read(read_size)
             if not chunk and read_size:
                 break
 
             chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
         suppress_health_check=[hypothesis.HealthCheck.large_base_example]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
     )
-    def test_stream_source_readall(self, original, level, streaming, source_read_size):
+    def test_stream_source_readall(
+        self, original, level, streaming, source_read_size
+    ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         data = dctx.stream_reader(source, read_size=source_read_size).readall()
         self.assertEqual(data, original)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_sizes=strategies.data(),
     )
     def test_stream_source_read1_variance(
         self, original, level, streaming, source_read_size, read_sizes
     ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(-1, 131072))
                 chunk = reader.read1(read_size)
                 if not chunk and read_size:
                     break
 
                 chunks.append(chunk)
 
         self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         streaming=strategies.booleans(),
         source_read_size=strategies.integers(1, 1048576),
         read_sizes=strategies.data(),
     )
     def test_stream_source_readinto1_variance(
         self, original, level, streaming, source_read_size, read_sizes
     ):
         cctx = zstd.ZstdCompressor(level=level)
 
         if streaming:
             source = io.BytesIO()
             writer = cctx.stream_writer(source)
             writer.write(original)
             writer.flush(zstd.FLUSH_FRAME)
             source.seek(0)
         else:
             frame = cctx.compress(original)
             source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
 
         chunks = []
         with dctx.stream_reader(source, read_size=source_read_size) as reader:
             while True:
                 read_size = read_sizes.draw(strategies.integers(1, 131072))
                 b = bytearray(read_size)
                 count = reader.readinto1(b)
 
                 if not count:
                     break
 
                 chunks.append(bytes(b[0:count]))
 
         self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 1048576),
         seek_amounts=strategies.data(),
         read_sizes=strategies.data(),
     )
     def test_relative_seeks(
         self, original, level, source_read_size, seek_amounts, read_sizes
     ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
 
         with dctx.stream_reader(frame, read_size=source_read_size) as reader:
             while True:
                 amount = seek_amounts.draw(strategies.integers(0, 16384))
                 reader.seek(amount, os.SEEK_CUR)
 
                 offset = reader.tell()
                 read_amount = read_sizes.draw(strategies.integers(1, 16384))
                 chunk = reader.read(read_amount)
 
                 if not chunk:
                     break
 
                 self.assertEqual(original[offset : offset + len(chunk)], chunk)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         originals=strategies.data(),
         frame_count=strategies.integers(min_value=2, max_value=10),
         level=strategies.integers(min_value=1, max_value=5),
         source_read_size=strategies.integers(1, 1048576),
         read_sizes=strategies.data(),
     )
     def test_multiple_frames(
         self, originals, frame_count, level, source_read_size, read_sizes
     ):
 
         cctx = zstd.ZstdCompressor(level=level)
         source = io.BytesIO()
         buffer = io.BytesIO()
         writer = cctx.stream_writer(buffer)
 
         for i in range(frame_count):
             data = originals.draw(strategies.sampled_from(random_input_data()))
             source.write(data)
             writer.write(data)
             writer.flush(zstd.FLUSH_FRAME)
 
         dctx = zstd.ZstdDecompressor()
         buffer.seek(0)
         reader = dctx.stream_reader(
             buffer, read_size=source_read_size, read_across_frames=True
         )
 
         chunks = []
 
         while True:
             read_amount = read_sizes.draw(strategies.integers(-1, 16384))
             chunk = reader.read(read_amount)
 
             if not chunk and read_amount:
                 break
 
             chunks.append(chunk)
 
         self.assertEqual(source.getvalue(), b"".join(chunks))
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestDecompressor_stream_writer_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         write_size=strategies.integers(min_value=1, max_value=8192),
         input_sizes=strategies.data(),
     )
-    def test_write_size_variance(self, original, level, write_size, input_sizes):
+    def test_write_size_variance(
+        self, original, level, write_size, input_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         dctx = zstd.ZstdDecompressor()
         source = io.BytesIO(frame)
         dest = NonClosingBytesIO()
 
         with dctx.stream_writer(dest, write_size=write_size) as decompressor:
             while True:
                 input_size = input_sizes.draw(strategies.integers(1, 4096))
                 chunk = source.read(input_size)
                 if not chunk:
                     break
 
                 decompressor.write(chunk)
 
         self.assertEqual(dest.getvalue(), original)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestDecompressor_copy_stream_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         read_size=strategies.integers(min_value=1, max_value=8192),
         write_size=strategies.integers(min_value=1, max_value=8192),
     )
-    def test_read_write_size_variance(self, original, level, read_size, write_size):
+    def test_read_write_size_variance(
+        self, original, level, read_size, write_size
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
         dest = io.BytesIO()
 
         dctx = zstd.ZstdDecompressor()
-        dctx.copy_stream(source, dest, read_size=read_size, write_size=write_size)
+        dctx.copy_stream(
+            source, dest, read_size=read_size, write_size=write_size
+        )
 
         self.assertEqual(dest.getvalue(), original)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestDecompressor_decompressobj_fuzzing(TestCase):
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         chunk_sizes=strategies.data(),
     )
     def test_random_input_sizes(self, original, level, chunk_sizes):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj()
 
         chunks = []
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
             chunk = source.read(chunk_size)
             if not chunk:
                 break
 
             chunks.append(dobj.decompress(chunk))
 
         self.assertEqual(b"".join(chunks), original)
 
     @hypothesis.settings(
         suppress_health_check=[
             hypothesis.HealthCheck.large_base_example,
             hypothesis.HealthCheck.too_slow,
         ]
     )
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         write_size=strategies.integers(
-            min_value=1, max_value=4 * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE
+            min_value=1,
+            max_value=4 * zstd.DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE,
         ),
         chunk_sizes=strategies.data(),
     )
-    def test_random_output_sizes(self, original, level, write_size, chunk_sizes):
+    def test_random_output_sizes(
+        self, original, level, write_size, chunk_sizes
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
         dobj = dctx.decompressobj(write_size=write_size)
 
         chunks = []
         while True:
             chunk_size = chunk_sizes.draw(strategies.integers(1, 4096))
             chunk = source.read(chunk_size)
             if not chunk:
                 break
 
             chunks.append(dobj.decompress(chunk))
 
         self.assertEqual(b"".join(chunks), original)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 @make_cffi
 class TestDecompressor_read_to_iter_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.sampled_from(random_input_data()),
         level=strategies.integers(min_value=1, max_value=5),
         read_size=strategies.integers(min_value=1, max_value=4096),
         write_size=strategies.integers(min_value=1, max_value=4096),
     )
-    def test_read_write_size_variance(self, original, level, read_size, write_size):
+    def test_read_write_size_variance(
+        self, original, level, read_size, write_size
+    ):
         cctx = zstd.ZstdCompressor(level=level)
         frame = cctx.compress(original)
 
         source = io.BytesIO(frame)
 
         dctx = zstd.ZstdDecompressor()
         chunks = list(
-            dctx.read_to_iter(source, read_size=read_size, write_size=write_size)
+            dctx.read_to_iter(
+                source, read_size=read_size, write_size=write_size
+            )
         )
 
         self.assertEqual(b"".join(chunks), original)
 
 
 @unittest.skipUnless("ZSTD_SLOW_TESTS" in os.environ, "ZSTD_SLOW_TESTS not set")
 class TestDecompressor_multi_decompress_to_buffer_fuzzing(TestCase):
     @hypothesis.given(
         original=strategies.lists(
-            strategies.sampled_from(random_input_data()), min_size=1, max_size=1024
+            strategies.sampled_from(random_input_data()),
+            min_size=1,
+            max_size=1024,
         ),
         threads=strategies.integers(min_value=1, max_value=8),
         use_dict=strategies.booleans(),
     )
     def test_data_equivalence(self, original, threads, use_dict):
         kwargs = {}
         if use_dict:
             kwargs["dict_data"] = zstd.ZstdCompressionDict(original[0])
 
         cctx = zstd.ZstdCompressor(
             level=1, write_content_size=True, write_checksum=True, **kwargs
         )
 
         if not hasattr(cctx, "multi_compress_to_buffer"):
             self.skipTest("multi_compress_to_buffer not available")
 
         frames_buffer = cctx.multi_compress_to_buffer(original, threads=-1)
 
         dctx = zstd.ZstdDecompressor(**kwargs)
         result = dctx.multi_decompress_to_buffer(frames_buffer)
 
         self.assertEqual(len(result), len(original))
         for i, frame in enumerate(result):
             self.assertEqual(frame.tobytes(), original[i])
 
         frames_list = [f.tobytes() for f in frames_buffer]
         result = dctx.multi_decompress_to_buffer(frames_list)
 
         self.assertEqual(len(result), len(original))
         for i, frame in enumerate(result):
             self.assertEqual(frame.tobytes(), original[i])

contrib/python-zstandard/tests/test_train_dictionary.py

@@ -1,92 +1,102 b''
 import struct
 import sys
 import unittest
 
 import zstandard as zstd
 
 from .common import (
     generate_samples,
     make_cffi,
     random_input_data,
     TestCase,
 )
 
 if sys.version_info[0] >= 3:
     int_type = int
 else:
     int_type = long
 
 
 @make_cffi
 class TestTrainDictionary(TestCase):
     def test_no_args(self):
         with self.assertRaises(TypeError):
             zstd.train_dictionary()
 
     def test_bad_args(self):
         with self.assertRaises(TypeError):
             zstd.train_dictionary(8192, u"foo")
 
         with self.assertRaises(ValueError):
             zstd.train_dictionary(8192, [u"foo"])
 
     def test_no_params(self):
         d = zstd.train_dictionary(8192, random_input_data())
         self.assertIsInstance(d.dict_id(), int_type)
 
         # The dictionary ID may be different across platforms.
         expected = b"\x37\xa4\x30\xec" + struct.pack("<I", d.dict_id())
 
         data = d.as_bytes()
         self.assertEqual(data[0:8], expected)
 
     def test_basic(self):
         d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16)
         self.assertIsInstance(d.dict_id(), int_type)
 
         data = d.as_bytes()
         self.assertEqual(data[0:4], b"\x37\xa4\x30\xec")
 
         self.assertEqual(d.k, 64)
         self.assertEqual(d.d, 16)
 
     def test_set_dict_id(self):
-        d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16, dict_id=42)
+        d = zstd.train_dictionary(
+            8192, generate_samples(), k=64, d=16, dict_id=42
+        )
         self.assertEqual(d.dict_id(), 42)
 
     def test_optimize(self):
-        d = zstd.train_dictionary(8192, generate_samples(), threads=-1, steps=1, d=16)
+        d = zstd.train_dictionary(
+            8192, generate_samples(), threads=-1, steps=1, d=16
+        )
 
         # This varies by platform.
         self.assertIn(d.k, (50, 2000))
         self.assertEqual(d.d, 16)
 
 
 @make_cffi
 class TestCompressionDict(TestCase):
     def test_bad_mode(self):
         with self.assertRaisesRegex(ValueError, "invalid dictionary load mode"):
             zstd.ZstdCompressionDict(b"foo", dict_type=42)
 
     def test_bad_precompute_compress(self):
         d = zstd.train_dictionary(8192, generate_samples(), k=64, d=16)
 
-        with self.assertRaisesRegex(ValueError, "must specify one of level or "):
+        with self.assertRaisesRegex(
+            ValueError, "must specify one of level or "
+        ):
             d.precompute_compress()
 
-        with self.assertRaisesRegex(ValueError, "must only specify one of level or "):
+        with self.assertRaisesRegex(
+            ValueError, "must only specify one of level or "
+        ):
             d.precompute_compress(
                 level=3, compression_params=zstd.CompressionParameters()
             )
 
     def test_precompute_compress_rawcontent(self):
         d = zstd.ZstdCompressionDict(
             b"dictcontent" * 64, dict_type=zstd.DICT_TYPE_RAWCONTENT
         )
         d.precompute_compress(level=1)
 
         d = zstd.ZstdCompressionDict(
             b"dictcontent" * 64, dict_type=zstd.DICT_TYPE_FULLDICT
         )
-        with self.assertRaisesRegex(zstd.ZstdError, "unable to precompute dictionary"):
+        with self.assertRaisesRegex(
+            zstd.ZstdError, "unable to precompute dictionary"
+        ):
             d.precompute_compress(level=1)

contrib/python-zstandard/zstandard/cffi.py

@@ -1,2615 +1,2769 b''
 # 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("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)
+        _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")
+            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_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")
+            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_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_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)
+        _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)
+        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)
+        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)
+        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)
+        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)
+        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_CCtxParams_setParameter(params, param, value)
     if lib.ZSTD_isError(zresult):
         raise ZstdError(
-            "unable to set compression context parameter: %s" % _zstd_error(zresult)
+            "unable to set compression context parameter: %s"
+            % _zstd_error(zresult)
         )
 
 
 def _get_compression_parameter(params, param):
     result = ffi.new("int *")
 
     zresult = lib.ZSTD_CCtxParams_getParameter(params, param, result)
     if lib.ZSTD_isError(zresult):
         raise ZstdError(
-            "unable to get compression context parameter: %s" % _zstd_error(zresult)
+            "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):
+    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))
+            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
+                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))
+                raise ZstdError(
+                    "zstd compress error: %s" % _zstd_error(zresult)
+                )
 
             if out_buffer.pos:
-                self._writer.write(ffi.buffer(out_buffer.dst, 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))
+                raise ZstdError(
+                    "zstd compress error: %s" % _zstd_error(zresult)
+                )
 
             if out_buffer.pos:
-                self._writer.write(ffi.buffer(out_buffer.dst, 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))
+                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):
+        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))
+                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"
+                "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))
+                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))
+                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._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))
+            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))
+            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())
+            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")
+            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")
+            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_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
+                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)
+                _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)
+        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)
+                "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)
+                    "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))
+            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))
+            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._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))
+            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))
+            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))
+                    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))
+            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)
+        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))
+            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))
+                    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))
+        raise ZstdError(
+            "cannot get frame parameters: %s" % _zstd_error(zresult)
+        )
 
     if zresult:
-        raise ZstdError("not enough data for frame parameters; need %d bytes" % 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):
+        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"
+                "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")
+            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))
+        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))
+                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")
+                raise ValueError(
+                    "cannot seek to negative position with SEEK_SET"
+                )
 
             if pos < self._bytes_decompressed:
-                raise ValueError("cannot seek zstd decompression stream " "backwards")
+                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")
+                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))
+            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))
+                raise ZstdError(
+                    "zstd decompress error: %s" % _zstd_error(zresult)
+                )
 
             if out_buffer.pos:
-                self._writer.write(ffi.buffer(out_buffer.dst, 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))
+        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")
+                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")
+            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)
+        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)
+                zresult = lib.ZSTD_decompressStream(
+                    self._dctx, out_buffer, in_buffer
+                )
                 if lib.ZSTD_isError(zresult):
-                    raise ZstdError("zstd decompress error: %s" % _zstd_error(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)
+        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)
+                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))
+        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))
+            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))
+            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)
+                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)
+            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)
+            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))
+            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)
+                    "unable to reference prepared dictionary: %s"
+                    % _zstd_error(zresult)
                 )

tests/test-check-format.t

@@ -1,5 +1,5 b''
 #require black
 
   $ cd $RUNTESTDIR/..
-  $ black --config=black.toml --check --diff `hg files 'set:(**.py + grep("^#!.*python")) - mercurial/thirdparty/** - "contrib/python-zstandard/**"'`
+  $ black --config=black.toml --check --diff `hg files 'set:(**.py + grep("^#!.*python")) - mercurial/thirdparty/**'`