From b560950f825fcd4da23222ea96424a61a71e4bf1 Mon Sep 17 00:00:00 2001 From: yilsem Date: Fri, 9 Oct 2026 16:27:55 +0300 Subject: [PATCH] fix(codex-bridge): ship zstd for the agent's Python and refuse to link without it Codex compresses request bodies with zstd. The agent venv is Python 3.11, which has no zstd in its standard library, so every Codex request failed on a fresh install. The matching zstandard build now ships beside the bridge; the status endpoint reports ok=false when bodies cannot be read, and the IDE then leaves Codex's config alone. A running bridge from an older build is replaced, and "Sync now" makes the bridge re-read the IDE session at once. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HRDGW1LiKcDUZYUdKBoWYW --- apps/desktop/assets/codex-bridge/bridge.py | 51 +- apps/desktop/assets/codex-bridge/test_zstd.py | 35 + .../licenses/LICENSE | 27 + .../cp311-win_amd64/zstandard/__init__.py | 217 + .../cp311-win_amd64/zstandard/__init__.pyi | 481 ++ .../zstandard/_cffi.cp311-win_amd64.pyd | Bin 0 -> 667136 bytes .../zstandard/backend_c.cp311-win_amd64.pyd | Bin 0 -> 524800 bytes .../cp311-win_amd64/zstandard/backend_cffi.py | 4478 +++++++++++++++++ .../vendor/cp311-win_amd64/zstandard/py.typed | 0 apps/desktop/electron/codex-link-config.ts | 3 +- apps/desktop/electron/codex-link.test.ts | 18 +- apps/desktop/electron/codex-link.ts | 13 +- apps/desktop/package.json | 4 +- 13 files changed, 5317 insertions(+), 10 deletions(-) create mode 100644 apps/desktop/assets/codex-bridge/test_zstd.py create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard-0.25.0.dist-info/licenses/LICENSE create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.py create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.pyi create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/_cffi.cp311-win_amd64.pyd create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/backend_c.cp311-win_amd64.pyd create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/backend_cffi.py create mode 100644 apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/py.typed diff --git a/apps/desktop/assets/codex-bridge/bridge.py b/apps/desktop/assets/codex-bridge/bridge.py index 9b34123..2be3604 100644 --- a/apps/desktop/assets/codex-bridge/bridge.py +++ b/apps/desktop/assets/codex-bridge/bridge.py @@ -26,9 +26,42 @@ from resim_context import resimleri_sadelestir import ide_catalog import ozet_kopru -SURUM = "1" +SURUM = "2" HERE = os.path.dirname(os.path.abspath(__file__)) +# Codex sends request bodies zstd-compressed. Python gained zstd in 3.14; for older +# interpreters the matching `zstandard` build ships next to this file. +_VENDOR = os.path.join(HERE, "vendor", "cp%d%d-win_amd64" % sys.version_info[:2]) +if os.path.isdir(_VENDOR): + sys.path.insert(0, _VENDOR) + + +def _zstd_decompress(body): + try: + from compression import zstd as _z + return _z.decompress(body) + except ImportError: + import zstandard + return zstandard.ZstdDecompressor().decompressobj().decompress(body) + + +def _zstd_ready(): + try: + try: + from compression import zstd as _z + sample = _z.compress(b"aiturk") + except ImportError: + import zstandard + sample = zstandard.ZstdCompressor().compress(b"aiturk") + return _zstd_decompress(sample) == b"aiturk" + except Exception: + return False + + +# Without zstd every Codex request would fail; the status endpoint then reports +# ok=false so that the IDE never points Codex at this bridge. +ZSTD_OK = _zstd_ready() + def _arg(name, env): """--name from the command line, else the environment variable.""" @@ -468,10 +501,7 @@ def decompress(body, enc): if enc == "deflate": import zlib; return zlib.decompress(body) if enc == "zstd": - try: - from compression import zstd as _z; return _z.decompress(body) - except ImportError: - import zstandard; return zstandard.ZstdDecompressor().decompressobj().decompress(body) + return _zstd_decompress(body) if enc == "br": import brotli; return brotli.decompress(body) return body @@ -533,9 +563,18 @@ class H(http.server.BaseHTTPRequestHandler): def _control(self, path): """Local status/stop for AITURK IDE. Loopback only; carries no secrets.""" + if self.command == "POST" and path.rstrip("/").endswith("/refresh"): + # The IDE asks for this after a sign-in or a settings change, so the model + # list does not wait for the next periodic refresh. + try: + load_ide_catalog() + except Exception as e: + log(f"katalog yenileme hatasi: {e}") + path = "/aiturk/codex-baglama/status" + self.command = "GET" if self.command == "GET" and path.rstrip("/").endswith("/status"): durum, _, sayi = (IDE_DURUM[0] or "kapali, 0 model").partition(", ") - return self._send_json(200, {"ok": True, "surum": SURUM, "ide_durum": durum, + return self._send_json(200, {"ok": ZSTD_OK, "surum": SURUM, "zstd": ZSTD_OK, "ide_durum": durum, "ide_model": int((sayi.split() or ["0"])[0]), "ozet": bool((CFG.get("ozet_kopru") or {}).get("enabled", False))}) if self.command == "POST" and path.rstrip("/").endswith("/stop"): diff --git a/apps/desktop/assets/codex-bridge/test_zstd.py b/apps/desktop/assets/codex-bridge/test_zstd.py new file mode 100644 index 0000000..7ac1723 --- /dev/null +++ b/apps/desktop/assets/codex-bridge/test_zstd.py @@ -0,0 +1,35 @@ +"""Codex compresses request bodies with zstd; the bridge must be able to read them.""" +import ast +import unittest +from pathlib import Path + +tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8")) +wanted = {"_zstd_decompress", "_zstd_ready", "decompress"} +env = {} +exec(compile(ast.Module(body=[n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name in wanted], + type_ignores=[]), "bridge.py", "exec"), env) + + +class Zstd(unittest.TestCase): + def test_self_check_matches_reality(self): + try: + try: + from compression import zstd as z + packed = z.compress(b"govde" * 50) + except ImportError: + import zstandard + packed = zstandard.ZstdCompressor().compress(b"govde" * 50) + except ImportError: + self.assertFalse(env["_zstd_ready"]()) # no zstd here: the bridge must say so + return + self.assertTrue(env["_zstd_ready"]()) + self.assertEqual(env["decompress"](packed, "zstd"), b"govde" * 50) + + def test_other_encodings(self): + import gzip + self.assertEqual(env["decompress"](gzip.compress(b"x"), "gzip"), b"x") + self.assertEqual(env["decompress"](b"duz", None), b"duz") + + +if __name__ == "__main__": + unittest.main() diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard-0.25.0.dist-info/licenses/LICENSE b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard-0.25.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000..b529554 --- /dev/null +++ b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard-0.25.0.dist-info/licenses/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2016, Gregory Szorc +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.py b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.py new file mode 100644 index 0000000..f68bfae --- /dev/null +++ b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.py @@ -0,0 +1,217 @@ +# Copyright (c) 2017-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. + +# ruff: noqa: F403, F405 + +"""Python interface to the Zstandard (zstd) compression library.""" + +from __future__ import absolute_import, unicode_literals + +# This module serves 2 roles: +# +# 1) Export the C or CFFI "backend" through a central module. +# 2) Implement additional functionality built on top of C or CFFI backend. +import builtins +import io +import os +import platform +import sys + +if sys.version_info >= (3, 12): + from collections.abc import Buffer +else: + from typing import ByteString as Buffer + +# Some Python implementations don't support C extensions. That's why we have +# a CFFI implementation in the first place. The code here import one of our +# "backends" then re-exports the symbols from this module. For convenience, +# we support falling back to the CFFI backend if the C extension can't be +# imported. But for performance reasons, we only do this on unknown Python +# implementation. Notably, for CPython we require the C extension by default. +# Because someone will inevitably want special behavior, the behavior is +# configurable via an environment variable. A potentially better way to handle +# this is to import a special ``__importpolicy__`` module or something +# defining a variable and `setup.py` could write the file with whatever +# policy was specified at build time. Until someone needs it, we go with +# the hacky but simple environment variable approach. +_module_policy = os.environ.get( + "PYTHON_ZSTANDARD_IMPORT_POLICY", "default" +).strip() + +if _module_policy == "default": + if platform.python_implementation() in ("CPython",): + from .backend_c import * # type: ignore + + backend = "cext" + elif platform.python_implementation() in ("PyPy",): + from .backend_cffi import * # type: ignore + + backend = "cffi" + else: + try: + from .backend_c import * + + backend = "cext" + except ImportError: + from .backend_cffi import * + + backend = "cffi" +elif _module_policy == "cffi_fallback": + try: + from .backend_c import * + + backend = "cext" + except ImportError: + from .backend_cffi import * + + backend = "cffi" +elif _module_policy == "rust": + from .backend_rust import * # type: ignore + + backend = "rust" +elif _module_policy == "cext": + from .backend_c import * + + backend = "cext" +elif _module_policy == "cffi": + from .backend_cffi import * + + backend = "cffi" +else: + raise ImportError( + "unknown module import policy: %s; use default, cffi_fallback, " + "cext, or cffi" % _module_policy + ) + +# Keep this in sync with python-zstandard.h, rust-ext/src/lib.rs, and debian/changelog. +__version__ = "0.25.0" + +_MODE_CLOSED = 0 +_MODE_READ = 1 +_MODE_WRITE = 2 + + +def open( + filename, + mode="rb", + cctx=None, + dctx=None, + encoding=None, + errors=None, + newline=None, + closefd=None, +): + """Create a file object with zstd (de)compression. + + The object returned from this function will be a + :py:class:`ZstdDecompressionReader` if opened for reading in binary mode, + a :py:class:`ZstdCompressionWriter` if opened for writing in binary mode, + or an ``io.TextIOWrapper`` if opened for reading or writing in text mode. + + :param filename: + ``bytes``, ``str``, or ``os.PathLike`` defining a file to open or a + file object (with a ``read()`` or ``write()`` method). + :param mode: + ``str`` File open mode. Accepts any of the open modes recognized by + ``open()``. + :param cctx: + ``ZstdCompressor`` to use for compression. If not specified and file + is opened for writing, the default ``ZstdCompressor`` will be used. + :param dctx: + ``ZstdDecompressor`` to use for decompression. If not specified and file + is opened for reading, the default ``ZstdDecompressor`` will be used. + :param encoding: + ``str`` that defines text encoding to use when file is opened in text + mode. + :param errors: + ``str`` defining text encoding error handling mode. + :param newline: + ``str`` defining newline to use in text mode. + :param closefd: + ``bool`` whether to close the file when the returned object is closed. + Only used if a file object is passed. If a filename is specified, the + opened file is always closed when the returned object is closed. + """ + normalized_mode = mode.replace("t", "") + + if normalized_mode in ("r", "rb"): + dctx = dctx or ZstdDecompressor() + open_mode = "r" + raw_open_mode = "rb" + elif normalized_mode in ("w", "wb", "a", "ab", "x", "xb"): + cctx = cctx or ZstdCompressor() + open_mode = "w" + raw_open_mode = normalized_mode + if not raw_open_mode.endswith("b"): + raw_open_mode = raw_open_mode + "b" + else: + raise ValueError("Invalid mode: {!r}".format(mode)) + + if hasattr(os, "PathLike"): + types = (str, bytes, os.PathLike) + else: + types = (str, bytes) + + if isinstance(filename, types): # type: ignore + inner_fh = builtins.open(filename, raw_open_mode) + closefd = True + elif hasattr(filename, "read") or hasattr(filename, "write"): + inner_fh = filename + closefd = bool(closefd) + else: + raise TypeError( + "filename must be a str, bytes, file or PathLike object" + ) + + if open_mode == "r": + fh = dctx.stream_reader(inner_fh, closefd=closefd) + elif open_mode == "w": + fh = cctx.stream_writer(inner_fh, closefd=closefd) + else: + raise RuntimeError("logic error in zstandard.open() handling open mode") + + if "b" not in normalized_mode: + return io.TextIOWrapper( + fh, encoding=encoding, errors=errors, newline=newline + ) + else: + return fh + + +def compress(data: Buffer, level: int = 3) -> bytes: + """Compress source data using the zstd compression format. + + This performs one-shot compression using basic/default compression + settings. + + This method is provided for convenience and is equivalent to calling + ``ZstdCompressor(level=level).compress(data)``. + + If you find yourself calling this function in a tight loop, + performance will be greater if you construct a single ``ZstdCompressor`` + and repeatedly call ``compress()`` on it. + """ + cctx = ZstdCompressor(level=level) + + return cctx.compress(data) + + +def decompress(data: Buffer, max_output_size: int = 0) -> bytes: + """Decompress a zstd frame into its original data. + + This performs one-shot decompression using basic/default compression + settings. + + This method is provided for convenience and is equivalent to calling + ``ZstdDecompressor().decompress(data, max_output_size=max_output_size)``. + + If you find yourself calling this function in a tight loop, performance + will be greater if you construct a single ``ZstdDecompressor`` and + repeatedly call ``decompress()`` on it. + """ + dctx = ZstdDecompressor() + + return dctx.decompress(data, max_output_size=max_output_size) diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.pyi b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.pyi new file mode 100644 index 0000000..f1b406c --- /dev/null +++ b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.pyi @@ -0,0 +1,481 @@ +# 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 os +from typing import ( + IO, + BinaryIO, + ByteString, + Generator, + Iterable, + List, + Optional, + Set, + Tuple, + Union, +) + +FLUSH_BLOCK: int +FLUSH_FRAME: int + +COMPRESSOBJ_FLUSH_FINISH: int +COMPRESSOBJ_FLUSH_BLOCK: int + +CONTENTSIZE_UNKNOWN: int +CONTENTSIZE_ERROR: int + +MAX_COMPRESSION_LEVEL: int + +COMPRESSION_RECOMMENDED_INPUT_SIZE: int +COMPRESSION_RECOMMENDED_OUTPUT_SIZE: int + +DECOMPRESSION_RECOMMENDED_INPUT_SIZE: int +DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE: int + +BLOCKSIZELOG_MAX: int +BLOCKSIZE_MAX: int + +WINDOWLOG_MIN: int +WINDOWLOG_MAX: int + +CHAINLOG_MIN: int +CHAINLOG_MAX: int +HASHLOG_MIN: int +HASHLOG_MAX: int +MINMATCH_MIN: int +MINMATCH_MAX: int +SEARCHLOG_MIN: int +SEARCHLOG_MAX: int +SEARCHLENGTH_MIN: int +SEARCHLENGTH_MAX: int +TARGETLENGTH_MIN: int +TARGETLENGTH_MAX: int +LDM_MINMATCH_MIN: int +LDM_MINMATCH_MAX: int +LDM_BUCKETSIZELOG_MAX: int + +STRATEGY_FAST: int +STRATEGY_DFAST: int +STRATEGY_GREEDY: int +STRATEGY_LAZY: int +STRATEGY_LAZY2: int +STRATEGY_BTLAZY2: int +STRATEGY_BTOPT: int +STRATEGY_BTULTRA: int +STRATEGY_BTULTRA2: int + +DICT_TYPE_AUTO: int +DICT_TYPE_RAWCONTENT: int +DICT_TYPE_FULLDICT: int + +FORMAT_ZSTD1: int +FORMAT_ZSTD1_MAGICLESS: int + +ZSTD_VERSION: Tuple[int, int, int] +FRAME_HEADER: bytes +MAGIC_NUMBER: int + +backend: str +backend_features: Set[str] +__version__: str + +class ZstdError(Exception): ... + +class BufferSegment(object): + offset: int + def __len__(self) -> int: ... + def tobytes(self) -> bytes: ... + +class BufferSegments(object): + def __len__(self) -> int: ... + def __getitem__(self, i: int) -> BufferSegment: ... + +class BufferWithSegments(object): + size: int + def __init__(self, data: ByteString, segments: ByteString): ... + def __len__(self) -> int: ... + def __getitem__(self, i: int) -> BufferSegment: ... + def segments(self): ... + def tobytes(self) -> bytes: ... + +class BufferWithSegmentsCollection(object): + def __init__(self, *args): ... + def __len__(self) -> int: ... + def __getitem__(self, i: int) -> BufferSegment: ... + def size(self) -> int: ... + +class ZstdCompressionParameters(object): + @staticmethod + def from_level( + level: int, source_size: int = ..., dict_size: int = ..., **kwargs + ) -> "ZstdCompressionParameters": ... + def __init__( + self, + format: int = ..., + compression_level: int = ..., + window_log: int = ..., + hash_log: int = ..., + chain_log: int = ..., + search_log: int = ..., + min_match: int = ..., + target_length: int = ..., + strategy: int = ..., + write_content_size: int = ..., + write_checksum: int = ..., + write_dict_id: int = ..., + job_size: int = ..., + overlap_log: int = ..., + force_max_window: int = ..., + enable_ldm: int = ..., + ldm_hash_log: int = ..., + ldm_min_match: int = ..., + ldm_bucket_size_log: int = ..., + ldm_hash_rate_log: int = ..., + threads: int = ..., + ): ... + @property + def format(self) -> int: ... + @property + def compression_level(self) -> int: ... + @property + def window_log(self) -> int: ... + @property + def hash_log(self) -> int: ... + @property + def chain_log(self) -> int: ... + @property + def search_log(self) -> int: ... + @property + def min_match(self) -> int: ... + @property + def target_length(self) -> int: ... + @property + def strategy(self) -> int: ... + @property + def write_content_size(self) -> int: ... + @property + def write_checksum(self) -> int: ... + @property + def write_dict_id(self) -> int: ... + @property + def job_size(self) -> int: ... + @property + def overlap_log(self) -> int: ... + @property + def force_max_window(self) -> int: ... + @property + def enable_ldm(self) -> int: ... + @property + def ldm_hash_log(self) -> int: ... + @property + def ldm_min_match(self) -> int: ... + @property + def ldm_bucket_size_log(self) -> int: ... + @property + def ldm_hash_rate_log(self) -> int: ... + @property + def threads(self) -> int: ... + def estimated_compression_context_size(self) -> int: ... + +class CompressionParameters(ZstdCompressionParameters): ... + +class ZstdCompressionDict(object): + k: int + d: int + def __init__( + self, + data: ByteString, + dict_type: int = ..., + k: int = ..., + d: int = ..., + ): ... + def __len__(self) -> int: ... + def dict_id(self) -> int: ... + def as_bytes(self) -> bytes: ... + def precompute_compress( + self, + level: int = ..., + compression_params: ZstdCompressionParameters = ..., + ): ... + +class ZstdCompressionObj(object): + def compress(self, data: ByteString) -> bytes: ... + def flush(self, flush_mode: int = ...) -> bytes: ... + +class ZstdCompressionChunker(object): + def compress(self, data: ByteString): ... + def flush(self): ... + def finish(self): ... + +class ZstdCompressionReader(BinaryIO): + def __enter__(self) -> "ZstdCompressionReader": ... + def __exit__(self, exc_type, exc_value, exc_tb): ... + def readable(self) -> bool: ... + def writable(self) -> bool: ... + def seekable(self) -> bool: ... + def readline(self, limit: int = ...) -> bytes: ... + def readlines(self, hint: int = ...) -> List[bytes]: ... + def write(self, data: ByteString): ... + def writelines(self, data: Iterable[bytes]): ... + def isatty(self) -> bool: ... + def flush(self): ... + def close(self): ... + @property + def closed(self) -> bool: ... + def tell(self) -> int: ... + def readall(self) -> bytes: ... + def __iter__(self): ... + def __next__(self): ... + def next(self): ... + def read(self, size: int = ...) -> bytes: ... + def read1(self, size: int = ...) -> bytes: ... + def readinto(self, b) -> int: ... + def readinto1(self, b) -> int: ... + +class ZstdCompressionWriter(BinaryIO): + def __enter__(self) -> "ZstdCompressionWriter": ... + def __exit__(self, exc_type, exc_value, exc_tb): ... + def memory_size(self) -> int: ... + def fileno(self) -> int: ... + def close(self): ... + @property + def closed(self) -> bool: ... + def isatty(self) -> bool: ... + def readable(self) -> bool: ... + def readline(self, size: int = ...) -> bytes: ... + def readlines(self, hint: int = ...) -> List[bytes]: ... + def seek(self, offset: int, whence: int = ...): ... + def seekable(self) -> bool: ... + def truncate(self, size: int = ...): ... + def writable(self) -> bool: ... + def writelines(self, lines: Iterable[bytes]): ... + def read(self, size: int = ...) -> bytes: ... + def readall(self) -> bytes: ... + def readinto(self, b): ... + def write(self, data: ByteString) -> int: ... + def flush(self, flush_mode: int = ...) -> int: ... + def tell(self) -> int: ... + +class ZstdCompressor(object): + def __init__( + self, + level: int = ..., + dict_data: Optional[ZstdCompressionDict] = ..., + compression_params: Optional[ZstdCompressionParameters] = ..., + write_checksum: Optional[bool] = ..., + write_content_size: Optional[bool] = ..., + write_dict_id: Optional[bool] = ..., + threads: int = ..., + ): ... + def memory_size(self) -> int: ... + def compress(self, data: ByteString) -> bytes: ... + def compressobj(self, size: int = ...) -> ZstdCompressionObj: ... + def chunker( + self, size: int = ..., chunk_size: int = ... + ) -> ZstdCompressionChunker: ... + def copy_stream( + self, + ifh: IO[bytes], + ofh: IO[bytes], + size: int = ..., + read_size: int = ..., + write_size: int = ..., + ) -> Tuple[int, int]: ... + def stream_reader( + self, + source: Union[IO[bytes], ByteString], + size: int = ..., + read_size: int = ..., + *, + closefd: bool = ..., + ) -> ZstdCompressionReader: ... + def stream_writer( + self, + writer: IO[bytes], + size: int = ..., + write_size: int = ..., + write_return_read: bool = ..., + *, + closefd: bool = ..., + ) -> ZstdCompressionWriter: ... + def read_to_iter( + self, + reader: Union[IO[bytes], ByteString], + size: int = ..., + read_size: int = ..., + write_size: int = ..., + ) -> Generator[bytes, None, None]: ... + def frame_progression(self) -> Tuple[int, int, int]: ... + def multi_compress_to_buffer( + self, + data: Union[ + BufferWithSegments, + BufferWithSegmentsCollection, + List[ByteString], + ], + threads: int = ..., + ) -> BufferWithSegmentsCollection: ... + +class ZstdDecompressionObj(object): + def decompress(self, data: ByteString) -> bytes: ... + def flush(self, length: int = ...) -> bytes: ... + @property + def unused_data(self) -> bytes: ... + @property + def unconsumed_tail(self) -> bytes: ... + @property + def eof(self) -> bool: ... + +class ZstdDecompressionReader(BinaryIO): + def __enter__(self) -> "ZstdDecompressionReader": ... + def __exit__(self, exc_type, exc_value, exc_tb): ... + def readable(self) -> bool: ... + def writable(self) -> bool: ... + def seekable(self) -> bool: ... + def readline(self, size: int = ...): ... + def readlines(self, hint: int = ...): ... + def write(self, data: ByteString): ... + def writelines(self, lines: Iterable[bytes]): ... + def isatty(self) -> bool: ... + def flush(self): ... + def close(self): ... + @property + def closed(self) -> bool: ... + def tell(self) -> int: ... + def readall(self) -> bytes: ... + def __iter__(self): ... + def __next__(self): ... + def next(self): ... + def read(self, size: int = ...) -> bytes: ... + def readinto(self, b) -> int: ... + def read1(self, size: int = ...) -> bytes: ... + def readinto1(self, b) -> int: ... + def seek(self, pos: int, whence: int = ...) -> int: ... + +class ZstdDecompressionWriter(BinaryIO): + def __enter__(self) -> "ZstdDecompressionWriter": ... + def __exit__(self, exc_type, exc_value, exc_tb): ... + def memory_size(self) -> int: ... + def close(self): ... + @property + def closed(self) -> bool: ... + def fileno(self) -> int: ... + def flush(self): ... + def isatty(self) -> bool: ... + def readable(self) -> bool: ... + def readline(self, size: int = ...): ... + def readlines(self, hint: int = ...): ... + def seek(self, offset: int, whence: int = ...): ... + def seekable(self) -> bool: ... + def tell(self): ... + def truncate(self, size: int = ...): ... + def writable(self) -> bool: ... + def writelines(self, lines: Iterable[bytes]): ... + def read(self, size: int = ...): ... + def readall(self): ... + def readinto(self, b): ... + def write(self, data: ByteString) -> int: ... + +class ZstdDecompressor(object): + def __init__( + self, + dict_data: Optional[ZstdCompressionDict] = ..., + max_window_size: int = ..., + format: int = ..., + ): ... + def memory_size(self) -> int: ... + def decompress( + self, + data: ByteString, + max_output_size: int = ..., + read_across_frames: bool = ..., + allow_extra_data: bool = ..., + ) -> bytes: ... + def stream_reader( + self, + source: Union[IO[bytes], ByteString], + read_size: int = ..., + read_across_frames: bool = ..., + *, + closefd=False, + ) -> ZstdDecompressionReader: ... + def decompressobj( + self, write_size: int = ..., read_across_frames: bool = False + ) -> ZstdDecompressionObj: ... + def read_to_iter( + self, + reader: Union[IO[bytes], ByteString], + read_size: int = ..., + write_size: int = ..., + skip_bytes: int = ..., + ) -> Generator[bytes, None, None]: ... + def stream_writer( + self, + writer: IO[bytes], + write_size: int = ..., + write_return_read: bool = ..., + *, + closefd: bool = ..., + ) -> ZstdDecompressionWriter: ... + def copy_stream( + self, + ifh: IO[bytes], + ofh: IO[bytes], + read_size: int = ..., + write_size: int = ..., + ) -> Tuple[int, int]: ... + def decompress_content_dict_chain( + self, frames: list[ByteString] + ) -> bytes: ... + def multi_decompress_to_buffer( + self, + frames: Union[ + BufferWithSegments, + BufferWithSegmentsCollection, + List[ByteString], + ], + decompressed_sizes: ByteString = ..., + threads: int = ..., + ) -> BufferWithSegmentsCollection: ... + +class FrameParameters(object): + content_size: int + window_size: int + dict_id: int + has_checksum: bool + +def estimate_decompression_context_size() -> int: ... +def frame_content_size(data: ByteString) -> int: ... +def frame_header_size(data: ByteString) -> int: ... +def get_frame_parameters( + data: ByteString, format: Optional[int] = None +) -> FrameParameters: ... +def train_dictionary( + dict_size: int, + samples: list[ByteString], + k: int = ..., + d: int = ..., + f: int = ..., + split_point: float = ..., + accel: int = ..., + notifications: int = ..., + dict_id: int = ..., + level: int = ..., + steps: int = ..., + threads: int = ..., +) -> ZstdCompressionDict: ... +def open( + filename: Union[bytes, str, os.PathLike, BinaryIO], + mode: str = ..., + cctx: Optional[ZstdCompressor] = ..., + dctx: Optional[ZstdDecompressor] = ..., + encoding: Optional[str] = ..., + errors: Optional[str] = ..., + newline: Optional[str] = ..., + closefd: bool = ..., +): ... +def compress(data: ByteString, level: int = ...) -> bytes: ... +def decompress(data: ByteString, max_output_size: int = ...) -> bytes: ... diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/_cffi.cp311-win_amd64.pyd b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/_cffi.cp311-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..865068db25afe266af0c5ee22eaf7c6ba93d9692 GIT binary patch literal 667136 zcmd?Sd3;nw_CDM!SHcoHD2*9KX(4D(#3-Xi5$z}$JDNyb(5N6$Sp_vpB2hqsA)0uJ z;yP{!E;#Pv#-^ZQQ4o;L4MiD79qj<4xD2wW{d=BMb=U3=!SDOu%Y4T4y|-@Fsj73H zI$PB(x@>x&RUi;(jsM5vfxvwH<-dshcOU<05eRhb_GZVx8*M*0Vt$Ll501EK)aY^H zvKy}-dE=GWhOfTzy6dhl4_`Grd}GCR;nCNH2MoM0eC_qahWANNZx%7xDM=>($?0Bd?nKyxbo?_Zj&+Z0=L|yBN=3!rzy_FP--- z{vI)Mw7hr3$SddmQ?4JMr~Y0o*B6YwdKBBTdRCkt2n@UZfI#Q$<)f^7I|ALq?OS&2 z9axeU2$Z3d`1ka?_?;m?tK<%Uw+sXhkXz2*Kvg?6nDV$3Mb%5zpTui*C+EAifx&oZ z8vee)I!oIHcJXhxU0_FF{?Px*+67j(4Fq;P-8RtGx|ihdD^IlzL=@@j>6WxW1oWo* z*Qb1VWjP)`+o1c&zLP0j|H7cE&yB;bEWZ+CmVwGqXW&5meGh+K{~}BU~D+{f$sS0`WIolHx3_r zJqmJ+0vM|Ri)1B~JJa>r|F3^WE{s-h4@b?Aj;)iJU zvhd|gS6lz0%Y~`t^S``{YyRxppo`#|GvmJI;JdFo_^vzpt|>6?@|}Ixy1VZ>+jrf|cYU<)y0`DTkMBCicYVC?`UKzgX};^zeb*7+HF?+F|G)XJqrU5N zeAmUk>kE9>!+h5xeAlCV*Q0&c*Z8i-_^vB`*Ia(w{Tc4N9_hQj&38S^cm0I#`bppQ zQ@-n`eb*~|*YEqTSNg7}Ljc_L-{ZT!*LVGk?>dG7aKGQ^yWZ-%-tN2pukZSM-}Mi^ z>m9!9AAQ$9`L2KVUH{^{{-5u9r|_ykb2dRd8G-Rj7oyo>S%whcu4z8kH}FNvBac{s7>wh=(#(rv+*nf>XO!)&jARm(tNe79(ILonKJ`S?~*^Sx;GmL0KU7l5o|wnXd8 zvx>Lj?$3qhr0hbo=ZWk{T}3!r6A#wDh`DuW9rFiACn}0`nu>jIRSZwL|%aL!oKh*}5Hy7DeLg3e8xw zdRM$67!UPF8*HE^hsDj%a8)Q8-+-}2>szdXovngxP_WQUe**UaVjl~h9**6wB7>m)U1D(s1v6uxgaE(R%N=4_?THG(J!_09kDl#!X_E`LH zu8c)@Q05zp3;B{coFnyHE1^3BbmxNZ&@O8-N%lPs*;&>Uwu{cUraCa%5B-Hd&0X=(I#n#AZ$qJ3lv!jh;~W;4A45R% z19kan(fWMQ3F)jG43<~yUPO`155y+UU?m&lq5Gtgweiq_QthgE==~M)sHkRVd0GK@ z?%zA(@u<0UTT95lSyU43`$6pSXIMnZs;OkvRI*w>yfklU-W7R6@&*raq#gPZ@Po)e zxdwd!Gm-|%90bY5Gm1XRWjUe=X-^6#?>vI$J#ga1lK`0scv1>HStk|E*&=@y#rVfG zI)1D1q(FA5s3uwGhRFF=0Lm z3&y;-Tw#m>6bAvrTiD`+=jn%o9>JIbM}o_#e{Z>mzaWSk*@* zg0BLiTzx!WH$U}ZVq9Gg`-l#rd4(P9DZB}(8Wm7KVoAMsshbv0x|2s&aVF5psAR;fNXB}4^%k) z`|MTe-vNpJo646=-t{Qal>#l>?uf<*PfS*3*v7w4lAU>$}Ci(6N=jf9lz9JeB7|T*bpAXWCytqg(1=0WbT_(lGMJ#Azb-gt&q6m2H3l^!b zuaYZj3!#<2$gDt|Y6&Xw&}U0IHo(v6C~MXW($wdd0hMa_T9Nrdp()H-T31vF9zdT4 zWaR=wMdZQ3ML=|s>!M78X<6*J2U#P)^lw5S!1P^d17JE)er&|jR*nf;6TAOM7ns%y z`T$SQqkd#6tTGi=nF_1wXU_sniICbjW<*-RGDh(i`V@7k>g~k@K2SO&g7p&EGzqJg zarnP6DxyDSD*Y*gJ%Ab%D(Cps7p3Jb0868%=oewmT+w%DJoGD^AB3S370iUP^9YR z^h8x_#TD_;%Ef#c>@YXC@b$rSxCqJFDz2bjn zUTgRI*~I)7)(r=r8>jv&)f_*|&U)v#?@mlHCfeK_4|M{`oWUG5%PaSIW_c;9RqAi@ zSzewn%g1vz6lPyq&j z%NQqsKF_*Tc?<47w%eKIU9u2CX&T5{YZ@vpjfcK@N0jS$=usA|j;GxijGFm@DY-J* zt<194@lY)uajgrr!F&9>7B7j4yQ#dBmurt~IF@y8{;t1bW2%6Mo!bX1N7S@ocJ=uT;{p*#)hm-wKfbr2uu zYl=ANYb;;Aw|0E%zMHnS{B=`2^p4a3rac{H0IWYe)dDq!(umLI3XImRQUKLRjnVj) z)vSDXZSe1w|0+T(38Uy)Qgo$a0Zr1cZ_Bt^Bn@2}B|64KlX;&~a}r*PhjQgrh|E0P z@B2PR9Ss0mP?qfujmCRkizhM+jpzQ*#yueWXCI#a1$rj<2DGDnm`fysb{Sg8QG$|| z(moVrE}O+usct_mQu1*Rv>6P@^U(gaC4})wzZy-;;J6ecN=lQeTgMkbl@bw{hmPvj z1(kv4l}U62+H;A>Eg%D+Cs=p@6{{qw+gH!Aj1dHh9uW!Fegt@TQD_=tc9I!<=HcON z1Ju{dRtnDBDCE-I=56vQI8AD9$2_0dMQU#2PzSoGG`G{yjH`=(U#Oa&dL-^UnvF+u zi$5z}>ty+g@*Dq`K>5jv@)gijFeT7A2beo3YS3?{>56L(LK)~cz410?1m%?8=C#A? zxe}>GIHf^*FUe4fTQQIs25rxIVu@?T?RnPWC~mE+p2-4FOFU6=8}kpDlZQaRniFl% zR$dtojd_#Lu)KCxy`zB&a}^6hzE(nDyAG%;&kDz)+uEQg;3NJs2LkwYtGo;ZIZ=K% zYE)6orAEOUgcY{kLu{zIHfdwO3;p`je)yx-e3}Yx$~j#BH@ukwyOX@C@#a(vh6`_g zM$`L^H)5~*SUQY}e+HGM!kcz#$56eW^Kk z(;^Aw#GBE|#!ZSh*U~FRCTRk1K7L9lZ<$EB#+#BIiFnghS8UggO*$MEt{G_# z-gM^xdhupCdS)AnKD@b)&N23^3B1|+r1UHsv?bup-Z^{*ym{>h>0J|elRJ<_fj4(c zQQ%ES@yr2l-j!M$y!rC$1iX3VKEB;tyn!}V*|#BhNdt|^Qaa9IqrtreSJx~6F5Tog zxDNA2@$vy#e@)YOBe*z?u7CU;jAcI%n{pl+u3lE@HV?f1uURN&`O~ZTyKYXc{8^;j zT}H- zjgOR`#NxK=_{~|IJL9|mIt-*;TSC)TT_iN0tGcM9znlt!)5Ys`^HT@2dD}aVHFbyG#ZPBS7h5NG@hDbi z8eeU_zvnh5(ACNI!}c$1*;G9#p+-lv}_(_7HPUEcxC+ zit6Tw%e!t-nwr}_YcW)m?;7!%h)IOTlu6Wy+><0^mhBChg;}09Q8HQo5}q8+ z66(QzS#L+D6=nT+6o&@>JPNsF{i!w0m-T~_bTJHBABsBAMJ4MiIfag_SN~HrKlL@- zPa*5u9+fU;CU$X>;)k6vp&6YM4}9=TYkoL~&542y;UIcteI;#f%i9|gqU|Wy8oGd3 z_wV4&6taGjBKm5Q=9YEs0W^&TNCCra*zyi*=vG~C&1}|drhm^O^_I6c0v|_jbPdpp zwri)LOgywryhgx(jui(p!~+Xc1c9!Pi4?(JyjwF1uZnC2dli-9UYQ_B zC_NAe*IfAjkvq!$FXjHn|X_UW5=JGScKc%@C0_mB^Y(Wb0=)ph*{wP+uT^ z&>7~(4}lK2tD}%kpB`a@2prReS*5YinP`!^f(JjsoGl%1SHLkxAf;|mrs9|HS7KZR zKUQ!gy!i1WC*l8yA2VK5_;IYlkBgyJy6_{o%HmIFB_=l|^{H43>6;IOtR(ocgnhB_ zW04m>jszJNemt21KkgE{(s&Cxs}DcQ{P=M&^;$oEtfa38)Ys%G{J4f{y|Nd=^dEt| z=IRQck`!MTi67lm7ZrYdE~02h{La$NPhEohDe&WkzoTB$*odH$uZ#7HALcR~rMwQ* z71nOF=7+P=9Q-)UqFhDMsVm%xN^Jb-DMZ`&aTlFOtUKKzS~(ruy24Hgx)?o3nioGd z3eOrhe=W1&#*fo=y)|=C1o-hXi_}{n5CMLS{mjM>_A4HGL0oFUkE>7?&@f%zwDDt> zT>9}t1fFX<@dJ`t-+*Go5s0OrmBN$LIqc9#fkx$KLE0P zl0?Je0d~X!i@VsKvl8!ym&*c+aeS1-u(=g^{a`VJo-~5R zfhZ0J?T?CFU~v-2Yc5zkPf~nc45N!by(?W*VDW;;oedUUbn{d1v*b?FZajv?tz!2Y zFMxbs7q4Jtrcs9{F0gp=BWr$|3l=-r0x5UEVhAd+!D1(Q&oL~nWHJit-i-Sxl#TcA zMH$oB$qdc>+t&X_4$4 zCD~zZ7KDx_uZX9BUJ2gK7EeK@HY37_tT4OoHTZuxJ6jZYjM?mw-l)L zsm)wqzAM>vYwtnR%GVdM!Y7p8lTn!+TPQ<&E)RV_@#CrR$sjy(!Y9ftz^ss`rgKn@ zb|o@Z2S?KiGNz^~I7af1G94noh1GGZT{+EQ`l1giJ+!S9ix;L2C!hxo(}oNmRt7xE@B(iQK{ zA%9M+;!uK{OmLH_xT$`4#Lt#CM>2w#CNW2I53=y1HSbp(7+v1Ld`l-_h;V=2{4MBl zZ1-Jhfw~F3`!*~;i^?pTvVw}*Xa;|$%7-Xa@$z;J7H7jf#h77+@GyK}Wn>j^ygc6u znCCHK{xA4!IQT_s)*oU>OKC@#fb>q##`ezx97k_7R3l_Pyvs+D!8<=Oh;)H$nxR+Q&nOvR=f@%j2O} z;NU5wD|Mt4V}3@wqHV$Q_c$xt4zVVK85pC{Qr-C8%g>hCK%ObyC?NMNL>&@SA4hKy z(?vIxcMf*LPqn{dB5#AQ!9SjG`f0bac*=0PY}E9{*Q9TgPhpa~sb1EWGeJYgos!Y2!QRBdA_~ z5nN9{^lXVtYp7NwOF_~n^IQ9T|7Hv`Tp|kxzo^~QZGC_dk|`}d6xc37thXnoRbO!0UddKl!Rxy ziH&R&f<7P51{LLd5YRzSvAX7G0E7Esfl?U!1Ee4x+Djjc`2SHZn89*I%s9<2gDy^P z$&Umx2EnKwlv4yAvDtY%XY>8~JmHY5ql+8E)r|*K@6H^5iOmOiDx8ter}6izcON$X zRKB&L{!C$rW21|=hNtWiW;nvf44s4-289dE_hVanvt>?mYk0oIL`Z(6*FrI5TBwlsrL^y1bRW#%ogHG}-V-{4M$r5fa! zzlm<}Alyo1hL%*0O=I9EHdA71(^tsy3WnLIZm@K`y^y|MhsG6OLN_Qdf5B>s6~6xj zRHpb6IcD67qWO|JX5GX^2y6l=<88h~e~6`$W40!CM=b}~cmrCWm1Cyei1~^y@5K|n z_G3XwKNrKpRX}ljqB`RuIgo^8s5AZ3IKtu<1j+v*#w%llB#)){jPx$&{W|0yD@`4& zZJRhyyt*d&NmAWU+pATi&(v#P&hOg!}5Bdi9BYN-@Q_G1mQ z#|8xof&*4Z>s}M%u13*G za`WkxY;s5`w1-j1mIMC{&+)1bR=$*I3h55eV~?J-F2z2&9cf3<5PFjhEk!|6s9gDy zP@TpiN4stamrkS&O^QH2h=QiA^Dru+`C?Hw-azqKpf};&;$z2ubhQmG%-&C zWMXPu7tV-c&ahtS`+v1qW|^Z^na>$MOl=3blm0AWpYlG*fO03Tb<^kp!jSqey9k6K zZ*JYUVH;NOpTuvq1M|m7lIdH$54T2%tM?12YWdk}n5-3ig1m(!xIL&xQ0Y~vP*!m2 ze`@_+$eS9Ez(Z-Ay{el?83q(-!Du*wR5+w!4bR{VS~%2rC~|x(Fv4G3U$e2M81qqr z`6wlS%(dpik2Sr?r#`Gf{wlBr8XIhqu;5G|P)T7aRHFLbdRtU8AgZO%1RYUL4B00p zvYyAW=R8i#0?4RDR)S0y>XdbpAR)HI+KH@h(#hsXEci|mS;1U8>_pb?Q#o?RK+tD_ zj3lxGu_)%I@%uV7pbQXzOsM00wfISVYzm)=7~8u>&QonNKK8Y^%b?6Xf?|-~0p?Q9 zSM0tlt?=I|uVWc%E8alJaD%)80Ncs*N0r~Yn)kf=zDVq}a#B8|7;|2NIWM&&)|&5V z_2P`i@qO$$cdai|wpX!p$?eZ!Z&))AcJiz;7f?Q$VSk15bY`5=K%G*qv{-(dQcdQeLd7g2cVj?KPR$ja`fOV$g9|&$5Yv~ zwmC82LOIvloc>Ga5=T`6#dcO08U{1VUbR)RK~tnRw}EDhnO8|x_TYGEkod{KjUCt{ zD;*3x0?v#T_tq@=>j!)Ymb^)dgC&oZA6}L`MQBMhL3iK4_M2&fHf}o6=1szqi$7E8 zKd*u~Ss(nEw2m_3#U$~J*y@k=j64KC7sv2hHF@Wwx0*9Cj_Ehf`4gNurwUE`I1|9s zvnMLEIrAp8=iVEd*z3)=0PK-TX^{x z?^!Pm2e)EZ9Xm=jX*{bh1L}5Wp-=E)O z1^;z^4-}$={GLX*s5tPjUO>9>B-|XBabgW;eCca{f?W^bL@9j;dC+Q`EFF0_p)xH0 z8M0O2b#j=}e7Q~bMv!5-;UD6oByRZ6CvtR+HXzYwM2=AG`X6{!w5)|e{N|UN&8`*ahz~q*KrLosLf>dZM zhl%wOt$V!;FGlO$s>Gk=)m5wo|Kv5eWSke-sOw)d@c#vjcT)V%q|E#9KaLv?{{Ks~ z(ud$QBWwIc3Do)UoVf8HGRz6zu}{t9Jx4Q{a|@bw;s3A5@D}_>WeWdy25X-Ki)#Eo z4+3?BcnJYqAmuJRQuv?C;$TOmnbh6PDKzFH{^Y}daq*bO{dnTWe+-TgFSRCGzb=wn zCLx&^a1N>f4V=tiEkiyolCPuliS#n$gFW&jS<0FlZIVB!6p~vdlB`2MqZtU3MSyUk zrK+p0xrW=i;-Qz|jl!<@cxadu=7>xRobooAvAk_``Es)0wj=3l?bo3tD2$i?1!R_Y zF06Z-d{@D5bIvdl|Gi{-8IXwd5hJ z)|^behJ|YCHOw2{J5)%>{g9yC;>3&S_S*t??2fO}>?do^ObV$rzLh25?#IY!NT)YLZxhCN@gW=*q1-_1hMfueK?S>I?19_DLvrN} z@z4kGYKe<~D&u_Erw98jFyNGVioxNc6b28{NpM+Pa>+b$3HTPp#lQarDiH6$ec~Sz zPImkEALDH=Gl#h*3?4zEQZw_P$Nw}R{yzkQ!QHd)XLd@t_1+TBjx{uKZvsj8=O-#5UwB>2n!e^-yzdmj!(S;9HMKkA<|&&hpH{x_1=o%@fwU!(u(;9it{$24mFZpy^2|m@kHR7*>%q33v6~GgIe($% z)ESzSOLFR7AoJ#D}#uX|UaqaYKpj}R)Nnso@7G*npkmWxRT)ICKm#s25FC}1C8 z|1&BV0sEi$qJVJv7>4v$+*V31SEQ9gIYZ5K7p>L?2@Z8o@`EkV_dJ9+gLR;mOCGAX zmnPGf?wn~!0_K~NVCzf8l=-IgrJ?8zCr|53ndq)YUhsbUDNp^0WnfhWGDWojRoE+?PhUEbBy;Gz`V!P0M_-yD=BlxBfsbVBOEbg|24ndmJO%G#C3w}# zrR{O701l{_LT13eRVfBV{|&q-oH$0+030drI>LQ^gu?r=eC)-0(U*D;;W(zo`^ICs z`~5{K|HbCLVvI?Nj;C~-k&5@WQ+$2AXP*c19o#h>JnfC1h3JExI`ZA(S#HRZfQ2U< zmKa89!;x0V1tr}Hql`yQHgYW>LOEbNjxHk-@kDCm+H?)dm_{1tvpmo0JdiTneUouL zCxo(8sD>-#BH#vnJ9LHIgfc24DlN7ljAfDG&(VC5-sqSVgYRRe{18;J10*l-p4Z_g z6FBB_)}1myf_(pIFr%e;CXSTJI448$Mz~>!84Fkmk))d&D}kc`E3TEFtCB@#aTt_2 zruHJ%&5>Jmi=O2Z)9C)FHP@vIXP^%ns$8_~shARDTmSVXn#a!P+lKvNP9r&@o0LmhnEL3=%R!uXflA>kp$iu0~hT z=b7tZtt^_zQ-JFmy^QF5kqa>#5``Ft^F1c;UCj6GD8r-8>Ia39DH5qG%Ec^TTR8+A zS=*e0qMX=g2Wv(sWsPKnf64n`ga_q^FoLbWsd(9AeBxz?Qn7z7Wz*K~QJFDQ%~<{L zGIyX+{{8^z?hZc#07n}+c) zx*|@jh>tni6NpkV$7c9!I4`Fu=J-2;bS~zY|JeRA#~&lnSQ6&A4mH`#v6dt|%yA9< zMkIn~Sf^l)4Ps>)@z)cW<2Kd*m+%C=%+btomrxEc7=gT1ae09`MxzWegUKA2f&830 zoE<4SMV<1)v0<5-Db8h0WQvvY9++Z^{1B#a@+GJ7rk5WgGeT|mF_k^PyHJx2^eV%})~fHM|Bghc3>QoIu~a+4|I;vzn$ZpP`GjA`%RgWw$pQP# z4{71&e$w;#%%t^a$IA~_Z8Bc|Ivq&FhHFsF6)ztL1yq)U%j9)T_-9fQ6Fyyjc$b66 zc+WfEV!sU@#OhNn2df)bVF!SgeJ#({`4lPi$x|P&<~;1vC(DRI-ZdTZNOk_x&&WRm zi5%y5lrXP+#WUI4WXLcQ`*cIQEc!m27v+Y=!miG@fi2YYaa5+<(9k9aqCHm_@)5ef zbb$P?c$6#**;1@t<2aD0v`MN|l7QV(5udJzM@15pIuc{zI3b!0fKOo6WKlSV5CDfF z**|taxlRgCgMCxc!LCjFHnBF73s6hyey2VuIMg0LQo;cLfL4m<0#D&$zvV zm6^r?blppSJpk0oGgv?u6S6F!W1PpICUW!)RWO-3S%0=Q?(xvK&$B)xSO1zwbVKFuH|Mmgt?`Y4GjODd>YK{?_zqo+tgo-PzQ%q%Q=b=C z#nIPl5p-Vnex}ZMSzMW;xH2rBM(p}{p2FXZe6p|L79&$^Q7g`)@T-G4GxUnn`5w)j z`?Fle2cv0M)Rw1()043rB825qr9t@iGmR1NoN_v*+Ryai<(zOM01|!6rQXlwK~c;I?%E=_+f+ z_lI5QUIJ>=LSO98C%cuhWdW%#pR7B`*jGN;ofmU-jd}2_`xbhgPxb(wxPbC5j8`++ zwUtG(lTTL6(Y7{z`tr%jnFPX7Ya*ZQi$OwdThf#?pX_=%^>yGzv1<_LGwPbHe6o94 z$jK*Lb%#5jtU^5`)aD|pGZzm<$px?9A`Ut5`tc}}BA;x{L7MGDLJ8RZet8RQf3Ey+ z^2x4#&>g7}UrG3H?BD+7lQkaNITin>z~iko=zr4ut}TR&X5jIBc(q)3d;>yXE>s!`@rM9V%!?pLT$4A-n$rE^W$-zs+oBF$#8ZTJX$XW9X$SDC(W1> zsSzq1t%cNZI8eY>8?{b9rNH~~rgJ6%wj&4xbz&YR+^Q))pf|4#Sw zIcmm0kmzGW?cX_85syOR-5nk3&xk9Z6?atEw#JO*vLZn*e!%JwSuD!KiB(XAGjLhtb84?RgF_T~?X zm1L(6sgp|uHN%oVl!<Dv?V`{ z?P2^h2Rs4ql%;^)z(AO!M4tkBh9bVRA|BBZ+4+@@VQMD7-o~o6 zy@c$~FxKa_lZ0PYlB}dyJN)`HeO?^3_b^E*HZ)v*u25S`Z@*Uom9xT3<9o)ZJPK%g zoXe?dt|&v+PzbMLGO1s}PZPQr1gXso7vlR@;&lTvuR|@^s(?b+oHGbr=lLb=H7ma* zO@Nh8mEvIKABT`CN3(1@&8=BV4$yo3Sfn{te&ZNGxtD*N$hUZWg2lCA-`d@Q`0ic1 zxk+Aqe`P!<=1}W=iyU;x1*p&IIfiheOmp%r{(cS`<5W*{zP|!%zW-1Pm6a*x%eQF7 zQDXy7P$=yfJVqP%q?6mmi1BGW1P70`5IXr5=g{rrgy1fmOwLsK76a)dq8fGp%2;dU zfl$=N>Ajl)Ejqm`r5I-LIQiiPqkg>S1tVD?_nyMKQwG=&|H!Of(Df#E%3NH|qe3Jt zzIs{aQk=A$hWk8mxdWstP_v=(kf>RhmBw=)`mLXwUN`-r3dx3KX}qaV^vHDkH?8w$ zN-bT^9iP4H=9K(E;7!F3BjEva@k1B` zb>lY|)J@L?k0EiEtda~biY@+#0Pv$2^l7m@W)PCGnCe)BE+%O4~EhQ@sS!JM7rP?H@)Q~oqNZ2uvBWhBD(rzPg>^vg#Xod1AG zp_f1Sy`~NDpcBfueA&LV8dWQGnM1@G2PRps3Zn3bu^}BaXe^VPV3M<>7?@-a9W2aJ z+*zLFdriObsTV#nnUAsXM84(3N?f1vky&g!H$6H2+q$(|-XE{9<}+L2f7psTTts;F z>ej@6AOIp_@UewOQ@IXQa!hqT#!={`OYmn^x+gX;4swUQxk8v?-vIXCl zkFke7FcQ&3KE_pNany{v5x4M6tbKk#e+C5|;U57$m&Jhj7>f~oz{H1L`51SpHkpsn zLtJo}_RmoaxL}=Mu+&=cSIX;{`2s14nGeVhFFbUR8a?nJy6ft`q&y`&te)R0c|2^I z_}Vst-xxay(4FyN zON$NvL)63#d?yJ3Uhn`i1ceVtk>VY$*n>Fsm$2uUn^r>@frm11>yE=B` z@uc>REIDC$$}-N!(4{=TEVs~npJN`5#c^gYrnkUcoQDrEV?J{+sr+85G5iL!#A)NV zQcdHJX>1s;6vFl~L&0)2*f)3P&J3RJj`muzJvnL&N9q;FLtDjJhS7QgFPmU4R*)St zRhvvB%!MC}71Q49pn5n%Hv}UqbhGyLiGx}*N$_IXDL6vhCzKm z996sGp+eTcQLR5`XZ7yTP1sMfl&x>On1_K?Z#|%TPv-b-oSbZZde~;?^soN3d4Vbe``2o7PtF4rE3gNr^ zxaO$Q#A(&mWZ|#J-kwfAhP@3qfbHXnmw$5|2aI3d1}oV1b_9{1l|)jpx4mBqvCjYW zpCpjs;K)ok&WIyNwG?bBL62O^S*Pnc3(y1i$5FJfKd9k~=K4|yOq-s|NWZn;a~^Ta zF}$-uhGlp^#z(f{4JAkKUzmOx>NSl;bzIRrAKbo%Z{YkTJW;Eb>+9K{&<8|#)(f?mOl=`)RwA z7K)W?G%{x3HP1zNfd7>ND8G5$Qq^2h0Z8bg3gpB$*yl!mO&=AqS}umYChjT-$8pjE zzblT-4MjL(|0DU%SKvCG)^xB`16F=e-T*5X$q&ayA3ia`M(^I6GqNumy|Mkw)ciin z;dd29@}Hma{TPeuBZ}*D$-EJ8{WrwNBwTNOZ$1ZSyXd3v@Of3Wrzb2r-1Be^k?HxN zRq)N#2$_K;GT^x&OHBPUOuzh8;SGKP8sScrX34yflTjJGqZzVkrvUA_yrX^Tq0-SH z9LEG2X6Wd(r7DKEqAH*KbX8p|$!VWN3;sngT8ye5LO60PM{6Tc?x>1(= zK{hHJg6WJ%Sxo1z^z$ea*f~#B<%|BtN6GBpBl${d`xpAusJviC z3x1=7>H~fkV1>t?6l&NxKjAtrTnN=FN7TS#`DRJ%lPkm^!k3La`UiDlt$(O*VAsvr z!drEVV*G>i|3+wjsCh_kcodPFxn?ARWXtid6%ld#6O&zvNEh^;b9IiwPEOkDs!jw8xM+nB1g_QN^mgD#i!HNv&2fdJDC7#OgDpqierfVNoeDRE`1s`W~ zf#9X8mWoQ)YvO2vw9H09o&k)(!3-Bg@JWs;se%Ep_prw+0?Va_j0|?oFGcosu>#4g z!CI=uNK=ritx_kX>IwPb=qd}wxj?dB7!^1xed^N^Xl=&P5tCmcJ1`+vvZf6|XD|TiNE=hS$GuwV`wQqZZW;=;S6qvv1lX`Eauv^gx(XyRQUlnv*Y3+si z1>6x>SQln-I~wsNZBx@|2NFH#8mv7`NlFaSB)u+B^}4|#UYI&@%du;#{l&Dc?FB)R z%!HOcie!idHZjV6G>7CR^oeokW|HBOF9=5~k}m;a9+E4si-(RDpBi}h-}K50|K^89 zomPBNST{U8pl*0}?70b=RU4!rSoI8f6|B1ROb&^x=f3@kzwwC||0UmbVVH01OUrf) zO7bf~Kagie(u8dV_tg%?ASt6)!zu6L*C}@XVFc&dQ3kP1ahCj9^eq1X|4S{#Emn-1 zO?@0&@r%>S7K@0gXpM^K!jwh8xBVE*u9h1z=&9PnZO zGinwi3>&DOxM9Hg5kf60trf)@-=AVs%x`vro!D~4aGaaMpHyi-MZp1PeiU{kU^^cj z7{nLT2Ea>!xunXGpA&nyQp>|DQZMA;IH>^g@a-9_$${=au602-pdYyX)?qA?e1mSO z_bh61b>kR(hSXtiuYOa-{wL38m^#GbYz@gaXSd@r))Z%prRieq0(6Q~)J8FOOZ3{s z*gdZN6O28Awsw;An@=E*wzc+m@S@9F+i*GuPNm;W#3RSRRE$jn^VDNl#u$lkgU`S` zM=^Fjp12_Tbc|9nm6_LBwPtLc{vF^LTgpr$=fYv^EKr7wz_Xc{Tz_=5@>fhd^IeUZtvU_{v6YA%e<9k2+Nyh#|$_)zS zb2pdD%{ge0=HjjL3|u@~N`s5T^1~b7=q;JPjjLQF*+#hqrWtNmgeEyi$T;h@_|NHjG90JE0CtmwwK17HP9G9V?^cRcc z_GcY9xfh60;^Ohg`~#Jx^2ajHPQDs<0*8=a1Pz9}b7E34ct&O3~SNBUFle02Vs4t*L)q2kcO71gxyCX zK1A#UMC_HT;F&8G1&gDtHj;v+qyTYXhQ=5Nxm0R}hZ$`Edt|qufqSmi80TT)d=*4f zDgj5Zt7uEXJ|Z;XW|^2)v4V>QoaA^FuHWACRf>J)RAJrhT7~|L2Z0c=s-g;jfE-v1WAFAMfwhHb;fh__VaFTGL=MSIH_$D}@C}`~wl*L#dhc3G?s#uHp#^^hq zZ>Ndr={aQ*CJer>B;QWE54lYu7l;=jR2kQ6WNXv~D+(@SSTK)KgK#XE0Nr4EMW4b) z{M?9SbwJ70DPW^|u#E8l;%n9#skcQB&3&}GZh|PmD&=l`!0FeK>f>*TSsA-Xhqrs#=w6=c z9vZ{cv>-)J_l9dCrixl)caPI$ckhEEq&AA?xRc#_AJ9E^t!vbv|XwTF7B zLXo&jh53PwBf#7B@z7LpPeHW%p`3!ZWmt_c&P5pm5cSE8BBv?`gAm}4Z22Kx=npT@ zsMk&!fIQbpRY1Ln{BTgO?=R z#S)uzic9wS!v4tr`4~Qt|A8k!&90`ehRU_p&Q5FcpR>EA8#F` zXrG8DE@3|rW3>-qw9a|n$u7S!akefDo5BK2T?9zZ*nFMOz4*ci!N9F0{xKkPso^#luxGH ziT!$87#3`km{a%NVbZV8(k~UL)&N|`mrUapMx#7Z4kP4PRddCtcxZ|Epdi6Fqo7Yg zNfa6ekfJAP(H$sNLv+_j9T43b`QeD}j4RxtD+Rn`{6$L_rVdC{qTln^!-X=__ZsD@hRhs=Z-{W zsqBZV>3h_Sw{r;Ka+;S)S@N$K51&9)x~Bq14M+OrT{9FK@p$Ao#30-H%TK*Bg*7e)i9QL9V;yx-Xc|YWZV+gwXMSDK3|Upg zKg33S#DlMU&O#M7yxfiUT*S8~@f^hQq5u#OYZ! ziz4xLIO*5YpI@U_4K>#shC*0UFTm>>gL2TXLkD_fH8HC>@tB|aq{G+09Q1D;X4=N0 ze_{c5^)E|PF_m6Ss0_M)&|9HE>&cnc1@)T70`$T+Iaeu_p_}R-Qe0g*U>oQRV*mOp zmElGd(pZ#>{*8%x`X?Ks6xU^0ABS!ioo{ny^_Cs6jif_CQYj!Q7m(Bwwb+oPPB60L zv;~@gsS8DtASH>e%~wOxwar)gASqa@PcRyQCz!fo$G(Tw@GG50(ED+M(KK;Q0hZ2E z1u;VJ0-Z2^gE9z9BB|ihBAkal3_8QIJ2XfgD&+xEk4Oywsq^KB15%?ec7s$2)%_z6 zAi0)PUNFT}m{LF7>y&SN;jYy9w1oo#eW48aG)o3&js%+O7QMnN>`%+L@M)C7r&6Ly zDe$QSm)rWHlDq|N<;B9R62YfpjZejbPm(SM4?s~=FbhALhgi46X+>enKrjnroB^M` z3$aQqQFq}1OE-yFPjv>tN+`dWBfCyoePP=bb{VniPmN{vb|;@iZauflxhS{NIxEfE5IwblEOQw5bIku;v=4j_5A>mXm~4dj^Ni`#JYf9Iu6UK z)QI(_n2pAFLlcO9P$5uXDC9z{(OA@6-pS@5)&WWSN5ncDRoRGz zgFoGfbz@K6zip`z>+?=BIc*aAH&-FnwO2_0yoeRnHP_su5UT-&T!^*cEKmQMgIGs$ zoE2h~X~Y_bT5QCk1?~#Q{GGlj;eXY&WQY~dkgoLxZ5|~mSj*5PIPzXbdpw90#J&t& zbIn{S6uMRwDv57k-i_XF5Vi`bU84O6HmEpWk@p%FJ&Q=9Mkd1wX z@OVZF#qp5@1v}oUQ7|NL0tN4vx`2Y`$`1zxuRh<6f}@Cn;T9YMgj_wK07#X zNZw%gVSccn8V?DD9PiK-$XE)?vxQxw6K`SBrBxPD$37!NOFQoiq)SthBI2_FBi%DPTc;DQ9gEO)FSHyxqxrJ;MzPKC$U1 zPCkWcG4gkkyw|71BsJDuo&XD4Y+l9_E%9L>+1brOGDULNBqURDY>g^xNiPOnF5RS- zjyn!Ut`di2y2*}o@`7<#BFU}zl42ry}sKB3UT{{1A~#duq__S&Tk8$GsSd8}Gh7lqw|#O?=$3(EOsH?(#H#hp4!~Y*AqD z=6*Sf%K#)4P?ImHJ8L7eiL2D_E&NTX!u?p(Y*kQq;fjL#3s)4?owcs0{;Vyyy(88| zNT&y&4&Nwa(5s=}If6@5s=FI1Xi4&(BS(|z+6q{$obTF9zbs`Y<-!xWEgwLil5=%^^+4>~HuG@zqGEP}8s zk$1z_#HpXC)cz=(^58kZ^&s-xXn@InJ1SmG1D#4>Y)1t(%dV&lGM+7(a|g8N5*X!k zQ!@UeN9~8GXge>t6N9K@4x-!bITx+CpN#e6h&T$n(7OTJ_p7vl+JqQv85%(DQIP)K$?hp>4&{S5g1(uFg7O)t32dcsc#ao`7t`%T%4ZN# zljCqNMft^`&&O7yG!8S!W)_ulW^9H1dR=qPStx{=399Y^GY1u;dzIjImqFGXgQbFW z*e;ey#pv1zT+1!c{+vSZ=se%jc>lEK=qjTvm8_ptQX0>9$V|-PPI2IQn&O_r|B5l76;mTPFOV*XOh|u~t6dUE&rJ^L&GY0egkz12 zagc)a3V1U$W?*{KAG8F| z^bW1pGV2C-C*Cli=uDK=+k7x&cnv#!GU{i^t3_$>-e7z(1gEegsFXW`6jr(2*g&P4 zD!hR$LS@RO-2!1((VwG2FOYV*Gzg@`v$XnO}si-C#m0B4(rfDE~!vp^A;R{mbsinM8CD- z;klyU0?bo~-4??`$Em*;=z;mYg}zM3Vto_>vESP4W}5Cwy6nVSLf?5xx)k(vM|&=X z@EmazD(Gv2N6Db?wcmsV{{>&TPr5#asCuC9b^6O4=o{Oo+0b`H65eZ#%b zP)~Oe2NAQ3S+JnN1AYJ7E5vtCBp%g!BIOK=Ee!AwGpA|H0LLnFQeRQk`8kz%r zc^pLFIWN(-#Qt5Y@FAINE2R2&CJ6LRj`+h&c_uH_fW$2DpTxW7BZMtj$qos*xN72vqp*n zd5Yv^AWv)g;UG`felFxuJ6t~7O8#k1Fb#OaSRQmu>wCgX=ndyx46QFhEv^b(Eiiv% z3T|0}87nk@;ubJ0r59yY7Mg2;q-g0gY~>N1PJPXA&j9LmyK2XGDa39E)>ml0TVQ^| z@#%9EJ0>SyjD^{aPYsu{?orSKBY9U)6ZF{gf}C3aYXB+OKekT(EZWFFrg8Yu7)sIq zs^kVC58$X$4jQ>wHkop;7mu5#_Pq|oz{Y51;;c;a>m8|HbiF9Tb%`fgyK#3RX%(znH-yGIZY z`?w_00JhvNo8(rCK62PMA|IXHs zpw@~edp3v^BvJEbpbqp5JwVUaI#|b^EpDrOCdbdzSv>=xPS1Mnl*zall=&v(HUgw+ zEQGHVJ@aDS^}6PoAqwk)s$-d2&3ot=PshYBudwbgm15wUvWX}6Dy^1yvc!T~1SEgB1i76|^R>h1Wa}9U>m7$lJh4QiJYt!oBq2q1r-Htt> z_E8A79D+bXNs+m_!2DPslZRQXhciS_^C8q*K+E`G_J*fltr71QP&1AXJL8M)-=63~ z&H5^m4Sj9af7r1Z4ZJiJ(wGWq>Ss^K&7}I;ww|f=H32J)U$az&`3P6^#7K$0 zR;u(h+jzZ*%lZG;#%mm29!~Cm6cEfu3=o4)whBXDJ_E1sw+7dh4h5g!P=lMM1P4rp zNPY#{b14b6;;vItc^Muh)8KaeBusV~Nc0I#Hs0`Pa6iIPhi+t`8^p8cvvfC7;F&Ay zYv|93#1qd(q6%AsoA2P+KuE|cdXhMZvjoqQYH)oO@ueWlNBkItXYauwn4rPktZT0M zn}V~ysD6QA#a(x%zh=ymPBf8Q(70-43-=Bymp+!_dn%8F(O1DRNFNojur?w? z&vJeCo`EVhXNGpbS(yZ*Kt4I{Tg5y_pnu>C@;zia{Y*=q_o-aDj-#rf>8&{54uwKR z>iIu6=ih|(T(I<`_{$V5rTU)ArQZvC+zwx^kMs5St%l)=W@_MS`nzC9CpeP0QoBgr zz^WB9M-Z0B64?I^H#4u`)H%$27OCZ^3121;%fIknp?2e`3Cuh}G4tto0yzznMEgwM zAL$Z8CJer(a=Un`z^MJDpz}SI*(+L*i%taV-}c9(077$^Fvt|JW{bO4lw9nsUCE`yOP*R+!Is z*pMpNHR3+oC3AZc9yzOHnyoNz*d`MjN8HTEhOHIxUoxVmu$651J?tbgP^8wx>=2j2 zc&;Lu;cYAx!iKNV$`VY4!uXWKhNO1kAE1PzCdg+ijF?kLVa!t0o-fq8!`tAnEWS@h z+5~SmBtD=f988%O>kLxx-EDaQ#ww7e;`|=w+NgO3&c{?YDt-Vg|3YU>95onQ@k^c6 z3M2yZt=z;GQgK-0s+&D{C-yL-*(938{}())vF<1+^?!yd(OOGX{m;oY>%W`oqPPACX=OAf zF9XMg6`qm@*xaqG@x0*uIG8PZN~hrcO9u2?qIc~^hT@|N`0^->a8(SmSKd($EPZoU zXXxkawzXd%KSCSDQ3FYCsF3J;G0pU$OM@A00mrvpjB=A*L{nnBADhTZ^ML@0+VI0OZm87x!CVaVcFArFN%_ z{hj_=TsRcJ@?ODg>><=2PsWkMRRWqTT!%Qvejm^N{)ulOTfRz7kc^a2lc&)GAnTp{)`Hk1(QlKY<>QM3T3SgyRZ$4 zOlUB50l_w?$B3S_xPtQNc{y*?M>k z62dhLNs;b@^hS_Q>ma>2334{Q-N^xF1K$auAU<)^+fUz8@{Dev&(gy5rnlE*4vZRv zmw*u&&cYRhKBQ}|Q32RcR29l}Yhj&LnTl)Uq33q9kzMgnsVaxlIdGEVhq1q8YelPA z?qh9Ri;@uZuv~LG-^0S3r-y21dDjsmMg+S}1!dF_)%kl9S-JQ8B|)RpK4qh+&m;Hw z<1UF#*`9;R%0r^6`BT(v?7Jav{uZ_a;VI5DKZ`9FqjhRlDN5nYzyaoRZ0h4TWzh_L zZXdu!2Vs%p#Sy3-ORpY7?>xi#A`#kQR*9&%_D~2}ED$agu!VT-LR~01EsH@{bqXMb zJrXO$7aj}iAIl_(HL_YsY<9>z#V0jLWsS&qdq&$N5v>W1jSw9@(|U|PM*LiI(h;Ux)!UB3&7X@#b1gQ}K#RRCq>1im#WpjhY!{IaU75x?s)|xnk&8ACwV%I;Dv<9io-asOOO%6Kr!-n$Q-vp{ zgvY>=MR4?d$fPx#_|%%r2Dan((WMkZbhA*n4*6Bk1i*a~2*g|URCm?6ex2y*v41dw_b2u7@z+Nxc6xa|}W=CK#;%j1G^>7(U^$n<&+QMTWa{LvC`eSzMP=-Dr zcM3MvGmxk<+L8zoo>Z}B(&-kRo+O!vxx4h)DciTOsE+S7$ZK;%>#tkHriuRtp@Tku zcZA%IJt?7ks7^@Ywk;!KZdv&bx$4NY97{|jse~D8A}`>R74guQaOaRibyD|(3}q?T zN+uSFyU{%PZof9a?)f*!qNKP^@P={I^Gx=|N-bhiH{ntroH+tySO;gu$gwJ^o5k%z z)YgbaYwU%)T;MNw;vw>ZuJiCVG;QUW z5m9suz6PPRB4717i!SW)2G&K zMypBmsV=A~l|FSUonUOB34Q9xFFBOPS{QP^RYmJlC(^|8>r*lM!ceoNPwhgO2ZcQP z)G}3u`qZW3Is@}$sLCvTs+Z-L56FG+#AK8NPpp&r2+ub`Uv%I(nLgE9+VS`g!eo-| zAFyXl=u*ww zom`}tTH8+_uu>LR_S56(N{;>ZlUOB-#b&y#C*VMfP&k9SGmhJ2i|1r;L)E&%?`<$of! zJ|B+#?ON$riJZ@^^l?F1?LI35BvvA;lJ{KaU$p~O0*(=7Y-VV^Iy90IK;L2Q&Z)v* zU>$+yhLEIn)`94c3m2p96)vhZGSSXV+yOrKGc>4l2>8(o%wOP{!ot`850WV1Swxv) zTsIsYqB|W~bc%zH5BNv|&tVp~b%;ARvWzhgeiaKBwGQzp-@yJW@wg~E)7~n$j{Yn- zMQ(|QhKp+pzKO1?AX>=}>)F8HhC&?T8#O=0pKSa;C$?w|ryRWT3%uImDj0_vFy+hS znogd}4%SnS;n_rI7x>^%d~aA9-9%^Ca_!!V5CFHWU>7{QpOT-HWaEeEt5xWqM_+Ym zr=qRK4kW2mQMDwfKejz58mZP*XK}FnvCZ4kEcSt-Ph(CLPjF=@LQTedHj6Um!p`wY z$!xd?5?eT%%tOcA?4~c@i4**U_V&+)E2S;2R$Gq^_be&5Y`7>JbG#R;8)fc;Q)y|X zu;Kpt38%!k67*SIrM(w>IZ&ptoPK@34R?#Kx#klTf(^Hoh3ah^t_O%hcntlooug`b zUll-EvEkZD|M^_bBr}cY)bm_Cr)qmk8--bwH^)OS({DpI9F8(D&JgF%FSZoCsMuw& z$)Nv1v!k03F(e>LIQGXVvM&(pMAl79>kZTd_BG_1i1lb^&AyO4sCTrqD!aJUJD7do z+7sU+0ZGGAv#ZcO+svYU<=|W1e2hAVJqg5JP0|wB)zbf_Y-g=jxF9*+tvAr8qIE_8O+mqppAE1=#2y3O^Syq#4!iF>#Yi6SRA}lv*U-n zl_NCdwUAff9j!to;F<3@)>$Bik6&z8No>O5bAvAU()GgpMM!q=U*1%{7dn{L7ckaC1^iKIjsS{ z?FPe6gR_yqCW5q`(JBhk7}SA5St!>Oq|4g!$wcKxzg%fAa^7Vo7x~s%l!CM=dt&hS zPCl~yrs_SzD*D0oC*L>4>7Mx6p&KSOn9({*eS9u+>6ERFC|!O|_0|^U`TS3W|LIq~ zr$za}(dDhPHsbtEyy||1HS(jVx<;Pd>3iHkMAG|~vt&?yF`5-E(HZrFX!etdOfi}K$5&r$qO_v+m(%G=8khV1*cL--=Q%NN<#ZE5_) z9x@h?Ga@({|HZkjAOSNQ56w~Ty1(%n{UOeF*SY-<|FMnIC`?5N3KC3P0w<6DM zz&Wgo3;Hz_2G4AW*5^gesc#*@$7OMMiL>TXKh9u2CaT6F%FT+(xfwc@`VDSi%Oad7 zfCUT*mr=TLx_~UMl(YE&V+9_)uq#PcLEa#~2S~zEq=tq+sQ#-wM)l5z8rvg3;VUUs zQOckRETWru&2{5g6jz73_WRsi36fVu`|;2EXnj|lAiESD`5Bj+ft|INwK_c*(xG^0Z);fUh3Ye>b zQwK?5oeOoRA|+V~m}eQb9C4G$;Bjmv6Fx)6QwH;WIIuXFZ86NK`8N13Txv%@G_>D7 zv2WLah9v0;-^T${)~=F=!FI0ngbV0L!yY-3!UNVkabdlS^G&gajqean^TmY=@dk)5 z!V}YZj3{ z&uWzV_yPE*Zuj%Eiua-KV_})s4FRB4z<`?+LHADo9b+e43`NRFV;>}_pI!s5D>V1? z-6X6hL+DB_IWpBrQ`d1Um0l5M)Z*tt^TbmrDawYb%x4D=i`Fv{>?``Bu-F|Rt;AXeVwoPHG-^~S@g$sX8feTN*&oahZEKNRKXsK}FB|LG7{7D{-wMmIT zRFUk?7uiKc+RDLu!YlF9z5pd0H95UBdD_x1V$vE%2(|8fkrLR=lFb1gdI9k!=8KRs zV$TR?L6m36T`*Kvw!;#ge4{8eTx zMsEJPWw*s&*^0lyTv{ORp%vett!CuMML{cvOy|e7Kp$Op$nvG@T!J%5s)5M!*R4F`CYg8-OP+M(dBkNeW>)lijtnyvC}DU4xl5B8f@y zU9P1?0tC*|(u34;)Lu!ww3zP+wet~)vdke_T7tDYKkjhGs7zme+3v)Fa* zqp6Z%@SSI~d8fsj5yhKWc&M`0hYG2rd3`jZC0Y9gQ-2Tj5%|lEcu3I-m+$z#jA>c^Umt9J(gX&)v9GNH!8l z*5~JrVW`M|%=O{AX6yXiw^2w-AwVg8-v64f;T^*zT>TFJcVO_ zY1Fb7eV&?0te};%p6X)PqHcR8>aCcZ2_^bV; zI335*JtELOqR>5x(YY&rw&V}8K_97@9f-+?zM=Btb2*7|*LP<;bTY{1n4YK>?;Qvd z=-EUs(i>4JxfI<(nR_|zDg>?7!o)PLOO~K9&gn#^sXE_7ok{YnG%kg&afay6g?hM@ zE-E%)<7;9X*D*AEO``<#S@)sIC;Q_V6#MS}U%IhuZNcCw8$ah>H(n zzYo)M`G(xYT=tb>n9Hr=+mg9FG%+7*JD+;j`%F&ni?6bkArUB)Q7Dv{rQu<>LfP2w zTK{}n`eZZk_0}J)`9%YELKE?|E48*ig|DZgCmeT;uRkLc<-*sozx)Yp;F1OqlLTM8 zp|Vu?x^x2vu4#Nd<{g$XNX?^VfAjHm4E+3FeBBRu{QkeG z$F8U%l{{9_S+oy%jJ+u&hZ0HF@;Cuutps`OqieS0aSaN&z2 zd3=!`IQFRteW$bPQyz#)l*bns;_=Jl6{=SG{=2xtAdkN;u42oM2 z^7x*-?8xKhJqhyo=<^)#=F4M0nBJ-6QIw|S{@Gz$ElJE#E2Cs1(kecIx?MBQpFIJ6 z;XvzD#cgmpxa4k_#k%_=cLNv5Tzd}Cq}&~>m{`f3@BG=f#0{p_L8dA?ZdsM8$o#e* z^EswQF-Y{uolaHkqlmZUZu$4kmb=GTwSo$JqZ{RJDyp#Mj;V?+k5L*)=FsI*e@wo` zvrOzxV@B%)lJ)ts6Y#_(Qm1)HZqj4a$f}h@MPSHhGmirUY)jOW)L0!0;xamzNUb>QpwEkLcm8Z%k0TRN)gs8j}5v^_vDn5Cr z?Em{cbMNlm%_f4szkb5r$K07SbIzQZ`JOXp1p7jVnTNN8fHB!XLkIGr3+^#H$_;oU zMz{|oEjr5YItJ%lsj6GG7&#foM`lOCKjQ$-mh0 z*{J9)KK`Z;tX^56dL1HD-}ebC8R z`nO9ADsurok)e~tuIM}qwn0b|-l_fD9o7u?2+r?#>?M$=xJ_#$Z=`i)3~YG5HJ+qH+HDZh8@ zR58@HvXB(wM}YWU{}tj3gm`Xyw-N6p8pcMjFam5>nlEe#hqo#gKFD5+s5(=wT!>73)Z>F2Cta8aofiduu=GNU7gQ)bDv@1?DKV zs-rYp{jM{qSU7^D#&r~6q(uET{2Teg4+sXPl=^+67RFm>PE*sF5|G~dzMUn9L;3k> zD2L8EK{s3^anE9D+V`JVy!gEJDabgvcfWQv({ z?O-GVXZF)7pf-8xsNOFyq}o;)vI**YLLgmDI+QA|0GI=}@Ka9Uz-)o{|4CNGuMzuU z)xEU2B=fi}ey3(UC@xP{8o0vi-i9AJJ@yh~SfN1dsp z8{`|zW;~J$l(g~#Nz7*QKDWweT0f)fXK2djaK< z5+IN|R`k5*O$mV`3Oz5s#fa^~h@FMZ01ZJm;aIzKSYEUB1VlJ2W2)>S=q#qEAiI#TL~fn)TC?@0ZyjRf_R1CSE+ z>u1&PZl#{g`sLW`H|u|eIZvY&DfKgtaqq3_mmIZdIZ-6ETA8A_Z=cIlSm=7!+rEtkx z(C2Xehrm`)Q{#{zp{CG8j3UXn-x8_qI&6@~*+;`v%(nK)rk*-pK7yWlLb8FLDwm6d zo|^u#T~C!$Po45RQgj$G+mwDXca@2^l2j93NpY=Z*HoiPmC{sdk(Q*dBK#Kms-nAi zlCQpn1`z*)DN0|Jv;Le9?&0JqIk=kg;nkH7ZwXbGYOL>3S~mjlVt;!{DXpQf>DiRl zlMrPAvybFZ)J6XQaY}9~%(IZGv&vPsP vd;QaFfuh6EaI#9S;z^Ub(JiQouPeQ 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%0A(ItLg${F}iczrF2&iB+6k^$hhp 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 literal 0 HcmV?d00001 diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/backend_c.cp311-win_amd64.pyd b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/backend_c.cp311-win_amd64.pyd new file mode 100644 index 0000000000000000000000000000000000000000..0f545e3987924dd448e3c1a6172ac06d5039f732 GIT binary patch literal 524800 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

}qj^b1L10jQZ<8Jel#5u~~}8^s!a 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 items without + the overhead of Python object creation and management. Used with + APIs like :py:meth:`ZstdDecompressor.multi_decompress_to_buffer`, it + is possible to decompress many objects in parallel without the GIL + held, leading to even better performance. + """ + + @property + def size(self): + """Total sizein bytes of the backing buffer.""" + raise NotImplementedError() + + def __len__(self): + raise NotImplementedError() + + def __getitem__(self, i): + """Obtains a segment within the buffer. + + The returned object references memory within this buffer. + + :param i: + Integer index of segment to retrieve. + :return: + :py:class:`BufferSegment` + """ + raise NotImplementedError() + + def segments(self): + """Obtain the array of ``(offset, length)`` segments in the buffer. + + :return: + :py:class:`BufferSegments` + """ + raise NotImplementedError() + + def tobytes(self): + """Obtain bytes copy of this instance.""" + raise NotImplementedError() + + +class BufferWithSegmentsCollection: + """A virtual spanning view over multiple BufferWithSegments. + + Instances are constructed from 1 or more :py:class:`BufferWithSegments` + instances. The resulting object behaves like an ordered sequence whose + members are the segments within each ``BufferWithSegments``. + + If the object is composed of 2 ``BufferWithSegments`` instances with the + first having 2 segments and the second have 3 segments, then ``b[0]`` + and ``b[1]`` access segments in the first object and ``b[2]``, ``b[3]``, + and ``b[4]`` access segments from the second. + """ + + def __len__(self): + """The number of segments within all ``BufferWithSegments``.""" + raise NotImplementedError() + + def __getitem__(self, i): + """Obtain the ``BufferSegment`` at an offset.""" + raise NotImplementedError() + + +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.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): + """Low-level zstd compression parameters. + + This type represents a collection of parameters to control how zstd + compression is performed. + + Instances can be constructed from raw parameters or derived from a + base set of defaults specified from a compression level (recommended) + via :py:meth:`ZstdCompressionParameters.from_level`. + + >>> # Derive compression settings for compression level 7. + >>> params = zstandard.ZstdCompressionParameters.from_level(7) + + >>> # With an input size of 1MB + >>> params = zstandard.ZstdCompressionParameters.from_level(7, source_size=1048576) + + Using ``from_level()``, it is also possible to override individual compression + parameters or to define additional settings that aren't automatically derived. + e.g.: + + >>> params = zstandard.ZstdCompressionParameters.from_level(4, window_log=10) + >>> params = zstandard.ZstdCompressionParameters.from_level(5, threads=4) + + Or you can define low-level compression settings directly: + + >>> params = zstandard.ZstdCompressionParameters(window_log=12, enable_ldm=True) + + Once a ``ZstdCompressionParameters`` instance is obtained, it can be used to + configure a compressor: + + >>> cctx = zstandard.ZstdCompressor(compression_params=params) + + Some of these are very low-level settings. It may help to consult the official + zstandard documentation for their behavior. Look for the ``ZSTD_p_*`` constants + in ``zstd.h`` (https://github.com/facebook/zstd/blob/dev/lib/zstd.h). + """ + + @staticmethod + def from_level(level, source_size=0, dict_size=0, **kwargs): + """Create compression parameters from a compression level. + + :param level: + Integer compression level. + :param source_size: + Integer size in bytes of source to be compressed. + :param dict_size: + Integer size in bytes of compression dictionary to use. + :return: + :py:class:`ZstdCompressionParameters` + """ + 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", + "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, + write_content_size=1, + write_checksum=0, + write_dict_id=0, + job_size=0, + overlap_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, + threads=0, + ): + params = lib.ZSTD_createCCtxParams() + if params == ffi.NULL: + raise MemoryError() + + params = ffi.gc(params, lib.ZSTD_freeCCtxParams) + + self._params = params + + if threads < 0: + threads = _cpu_count() + + # We need to set ZSTD_c_nbWorkers before ZSTD_c_jobSize and ZSTD_c_overlapLog + # because setting ZSTD_c_nbWorkers resets the other parameters. + _set_compression_parameter(params, lib.ZSTD_c_nbWorkers, threads) + + _set_compression_parameter(params, lib.ZSTD_c_format, format) + _set_compression_parameter( + params, lib.ZSTD_c_compressionLevel, compression_level + ) + _set_compression_parameter(params, lib.ZSTD_c_windowLog, window_log) + _set_compression_parameter(params, lib.ZSTD_c_hashLog, hash_log) + _set_compression_parameter(params, lib.ZSTD_c_chainLog, chain_log) + _set_compression_parameter(params, lib.ZSTD_c_searchLog, search_log) + _set_compression_parameter(params, lib.ZSTD_c_minMatch, min_match) + _set_compression_parameter( + params, lib.ZSTD_c_targetLength, target_length + ) + + if strategy == -1: + strategy = 0 + + _set_compression_parameter(params, lib.ZSTD_c_strategy, strategy) + _set_compression_parameter( + params, lib.ZSTD_c_contentSizeFlag, write_content_size + ) + _set_compression_parameter( + params, lib.ZSTD_c_checksumFlag, write_checksum + ) + _set_compression_parameter(params, lib.ZSTD_c_dictIDFlag, write_dict_id) + _set_compression_parameter(params, lib.ZSTD_c_jobSize, job_size) + + if overlap_log == -1: + overlap_log = 0 + + _set_compression_parameter(params, lib.ZSTD_c_overlapLog, overlap_log) + _set_compression_parameter( + params, lib.ZSTD_c_forceMaxWindow, force_max_window + ) + _set_compression_parameter( + params, lib.ZSTD_c_enableLongDistanceMatching, enable_ldm + ) + _set_compression_parameter(params, lib.ZSTD_c_ldmHashLog, ldm_hash_log) + _set_compression_parameter( + params, lib.ZSTD_c_ldmMinMatch, ldm_min_match + ) + _set_compression_parameter( + params, lib.ZSTD_c_ldmBucketSizeLog, ldm_bucket_size_log + ) + + if ldm_hash_rate_log == -1: + ldm_hash_rate_log = 0 + + _set_compression_parameter( + params, lib.ZSTD_c_ldmHashRateLog, ldm_hash_rate_log + ) + + @property + def format(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_format) + + @property + def compression_level(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_compressionLevel + ) + + @property + def window_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_windowLog) + + @property + def hash_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_hashLog) + + @property + def chain_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_chainLog) + + @property + def search_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_searchLog) + + @property + def min_match(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_minMatch) + + @property + def target_length(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_targetLength) + + @property + def strategy(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_strategy) + + @property + def write_content_size(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_contentSizeFlag + ) + + @property + def write_checksum(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_checksumFlag) + + @property + def write_dict_id(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_dictIDFlag) + + @property + def job_size(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_jobSize) + + @property + def overlap_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_overlapLog) + + @property + def force_max_window(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_forceMaxWindow + ) + + @property + def enable_ldm(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_enableLongDistanceMatching + ) + + @property + def ldm_hash_log(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_ldmHashLog) + + @property + def ldm_min_match(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_ldmMinMatch) + + @property + def ldm_bucket_size_log(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_ldmBucketSizeLog + ) + + @property + def ldm_hash_rate_log(self): + return _get_compression_parameter( + self._params, lib.ZSTD_c_ldmHashRateLog + ) + + @property + def threads(self): + return _get_compression_parameter(self._params, lib.ZSTD_c_nbWorkers) + + def estimated_compression_context_size(self): + """Estimated size in bytes needed to compress with these parameters.""" + return lib.ZSTD_estimateCCtxSize_usingCCtxParams(self._params) + + +def estimate_decompression_context_size(): + """Estimate the memory size requirements for a decompressor instance. + + :return: + Integer number of bytes. + """ + 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) + ) + + +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) + ) + + return result[0] + + +class ZstdCompressionWriter(object): + """Writable compressing stream wrapper. + + ``ZstdCompressionWriter`` is a write-only stream interface for writing + compressed data to another stream. + + This type conforms to the ``io.RawIOBase`` interface and should be usable + by any type that operates against a *file-object* (``typing.BinaryIO`` + in Python type hinting speak). Only methods that involve writing will do + useful things. + + As data is written to this stream (e.g. via ``write()``), that data + is sent to the compressor. As compressed data becomes available from + the compressor, it is sent to the underlying stream by calling its + ``write()`` method. + + Both ``write()`` and ``flush()`` return the number of bytes written to the + object's ``write()``. In many cases, small inputs do not accumulate enough + data to cause a write and ``write()`` will return ``0``. + + Calling ``close()`` will mark the stream as closed and subsequent I/O + operations will raise ``ValueError`` (per the documented behavior of + ``io.RawIOBase``). ``close()`` will also call ``close()`` on the underlying + stream if such a method exists and the instance was constructed with + ``closefd=True`` + + Instances are obtained by calling :py:meth:`ZstdCompressor.stream_writer`. + + Typically usage is as follows: + + >>> cctx = zstandard.ZstdCompressor(level=10) + >>> compressor = cctx.stream_writer(fh) + >>> compressor.write(b"chunk 0\\n") + >>> compressor.write(b"chunk 1\\n") + >>> compressor.flush() + >>> # Receiver will be able to decode ``chunk 0\\nchunk 1\\n`` at this point. + >>> # Receiver is also expecting more data in the zstd *frame*. + >>> + >>> compressor.write(b"chunk 2\\n") + >>> compressor.flush(zstandard.FLUSH_FRAME) + >>> # Receiver will be able to decode ``chunk 0\\nchunk 1\\nchunk 2``. + >>> # Receiver is expecting no more data, as the zstd frame is closed. + >>> # Any future calls to ``write()`` at this point will construct a new + >>> # zstd frame. + + Instances can be used as context managers. Exiting the context manager is + the equivalent of calling ``close()``, which is equivalent to calling + ``flush(zstandard.FLUSH_FRAME)``: + + >>> cctx = zstandard.ZstdCompressor(level=10) + >>> with cctx.stream_writer(fh) as compressor: + ... compressor.write(b'chunk 0') + ... compressor.write(b'chunk 1') + ... ... + + .. important:: + + If ``flush(FLUSH_FRAME)`` is not called, emitted data doesn't + constitute a full zstd *frame* and consumers of this data may complain + about malformed input. It is recommended to use instances as a context + manager to ensure *frames* are properly finished. + + If the size of the data being fed to this streaming compressor is known, + you can declare it before compression begins: + + >>> cctx = zstandard.ZstdCompressor() + >>> with cctx.stream_writer(fh, size=data_len) as compressor: + ... compressor.write(chunk0) + ... compressor.write(chunk1) + ... ... + + Declaring the size of the source data allows compression parameters to + be tuned. And if ``write_content_size`` is used, it also results in the + content size being written into the frame header of the output data. + + The size of chunks being ``write()`` to the destination can be specified: + + >>> cctx = zstandard.ZstdCompressor() + >>> with cctx.stream_writer(fh, write_size=32768) as compressor: + ... ... + + To see how much memory is being used by the streaming compressor: + + >>> cctx = zstandard.ZstdCompressor() + >>> with cctx.stream_writer(fh) as compressor: + ... ... + ... byte_size = compressor.memory_size() + + Thte total number of bytes written so far are exposed via ``tell()``: + + >>> cctx = zstandard.ZstdCompressor() + >>> with cctx.stream_writer(fh) as compressor: + ... ... + ... total_written = compressor.tell() + + ``stream_writer()`` accepts a ``write_return_read`` boolean argument to + control the return value of ``write()``. When ``False`` (the default), + ``write()`` returns the number of bytes that were ``write()``'en to the + underlying object. When ``True``, ``write()`` returns the number of bytes + read from the input that were subsequently written to the compressor. + ``True`` is the *proper* behavior for ``write()`` as specified by the + ``io.RawIOBase`` interface and will become the default value in a future + release. + """ + + def __init__( + self, + compressor, + writer, + source_size, + write_size, + write_return_read, + closefd=True, + ): + self._compressor = compressor + self._writer = writer + self._write_size = write_size + self._write_return_read = bool(write_return_read) + self._closefd = bool(closefd) + self._entered = False + self._closing = False + self._closed = False + self._bytes_compressed = 0 + + self._dst_buffer = ffi.new("char[]", write_size) + self._out_buffer = ffi.new("ZSTD_outBuffer *") + self._out_buffer.dst = self._dst_buffer + self._out_buffer.size = len(self._dst_buffer) + self._out_buffer.pos = 0 + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(compressor._cctx, source_size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + def __enter__(self): + if self._closed: + raise ValueError("stream is closed") + + if self._entered: + raise ZstdError("cannot __enter__ multiple times") + + self._entered = True + return self + + def __exit__(self, exc_type, exc_value, exc_tb): + self._entered = False + self.close() + self._compressor = None + + return False + + def __iter__(self): + raise io.UnsupportedOperation() + + def __next__(self): + raise io.UnsupportedOperation() + + 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._closing = True + self.flush(FLUSH_FRAME) + finally: + self._closing = False + self._closed = True + + # Call close() on underlying stream as well. + f = getattr(self._writer, "close", None) + if self._closefd and 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): + """Send data to the compressor and possibly to the inner stream.""" + if self._closed: + raise ValueError("stream is closed") + + total_write = 0 + + data_buffer = ffi.from_buffer(data) + + in_buffer = ffi.new("ZSTD_inBuffer *") + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + out_buffer = self._out_buffer + out_buffer.pos = 0 + + while in_buffer.pos < in_buffer.size: + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, + out_buffer, + in_buffer, + lib.ZSTD_e_continue, + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + self._writer.write( + ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + ) + total_write += out_buffer.pos + self._bytes_compressed += out_buffer.pos + out_buffer.pos = 0 + + if self._write_return_read: + return in_buffer.pos + else: + return total_write + + def flush(self, flush_mode=FLUSH_BLOCK): + """Evict data from compressor's internal state and write it to inner stream. + + Calling this method may result in 0 or more ``write()`` calls to the + inner stream. + + This method will also call ``flush()`` on the inner stream, if such a + method exists. + + :param flush_mode: + How to flush the zstd compressor. + + ``zstandard.FLUSH_BLOCK`` will flush data already sent to the + compressor but not emitted to the inner stream. The stream is still + writable after calling this. This is the default behavior. + + See documentation for other ``zstandard.FLUSH_*`` constants for more + flushing options. + :return: + Integer number of bytes written to the inner stream. + """ + + if flush_mode == FLUSH_BLOCK: + flush = lib.ZSTD_e_flush + elif flush_mode == FLUSH_FRAME: + flush = lib.ZSTD_e_end + else: + raise ValueError("unknown flush_mode: %r" % flush_mode) + + if self._closed: + raise ValueError("stream is closed") + + total_write = 0 + + out_buffer = self._out_buffer + out_buffer.pos = 0 + + in_buffer = ffi.new("ZSTD_inBuffer *") + in_buffer.src = ffi.NULL + in_buffer.size = 0 + in_buffer.pos = 0 + + while True: + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, out_buffer, in_buffer, flush + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + self._writer.write( + ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + ) + total_write += out_buffer.pos + self._bytes_compressed += out_buffer.pos + out_buffer.pos = 0 + + if not zresult: + break + + f = getattr(self._writer, "flush", None) + if f and not self._closing: + f() + + return total_write + + def tell(self): + return self._bytes_compressed + + +class ZstdCompressionObj(object): + """A compressor conforming to the API in Python's standard library. + + This type implements an API similar to compression types in Python's + standard library such as ``zlib.compressobj`` and ``bz2.BZ2Compressor``. + This enables existing code targeting the standard library API to swap + in this type to achieve zstd compression. + + .. important:: + + The design of this API is not ideal for optimal performance. + + The reason performance is not optimal is because the API is limited to + returning a single buffer holding compressed data. When compressing + data, we don't know how much data will be emitted. So in order to + capture all this data in a single buffer, we need to perform buffer + reallocations and/or extra memory copies. This can add significant + overhead depending on the size or nature of the compressed data how + much your application calls this type. + + If performance is critical, consider an API like + :py:meth:`ZstdCompressor.stream_reader`, + :py:meth:`ZstdCompressor.stream_writer`, + :py:meth:`ZstdCompressor.chunker`, or + :py:meth:`ZstdCompressor.read_to_iter`, which result in less overhead + managing buffers. + + Instances are obtained by calling :py:meth:`ZstdCompressor.compressobj`. + + Here is how this API should be used: + + >>> cctx = zstandard.ZstdCompressor() + >>> cobj = cctx.compressobj() + >>> data = cobj.compress(b"raw input 0") + >>> data = cobj.compress(b"raw input 1") + >>> data = cobj.flush() + + Or to flush blocks: + + >>> cctx.zstandard.ZstdCompressor() + >>> cobj = cctx.compressobj() + >>> data = cobj.compress(b"chunk in first block") + >>> data = cobj.flush(zstandard.COMPRESSOBJ_FLUSH_BLOCK) + >>> data = cobj.compress(b"chunk in second block") + >>> data = cobj.flush() + + For best performance results, keep input chunks under 256KB. This avoids + extra allocations for a large output object. + + It is possible to declare the input size of the data that will be fed + into the compressor: + + >>> cctx = zstandard.ZstdCompressor() + >>> cobj = cctx.compressobj(size=6) + >>> data = cobj.compress(b"foobar") + >>> data = cobj.flush() + """ + + def __init__( + self, compressor, write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE + ): + self._compressor = compressor + self._out = ffi.new("ZSTD_outBuffer *") + self._dst_buffer = ffi.new("char[]", write_size) + self._out.dst = self._dst_buffer + self._out.size = write_size + self._out.pos = 0 + self._finished = False + + def compress(self, data): + """Send data to the compressor. + + This method receives bytes to feed to the compressor and returns + bytes constituting zstd compressed data. + + The zstd compressor accumulates bytes and the returned bytes may be + substantially smaller or larger than the size of the input data on + any given call. The returned value may be the empty byte string + (``b""``). + + :param data: + Data to write to the compressor. + :return: + Compressed data. + """ + if self._finished: + raise ZstdError("cannot call compress() after compressor finished") + + data_buffer = ffi.from_buffer(data) + source = ffi.new("ZSTD_inBuffer *") + source.src = data_buffer + source.size = len(data_buffer) + source.pos = 0 + + chunks = [] + + while source.pos < len(data): + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, self._out, source, lib.ZSTD_e_continue + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if self._out.pos: + chunks.append(ffi.buffer(self._out.dst, self._out.pos)[:]) + self._out.pos = 0 + + return b"".join(chunks) + + def flush(self, flush_mode=COMPRESSOBJ_FLUSH_FINISH): + """Emit data accumulated in the compressor that hasn't been outputted yet. + + The ``flush_mode`` argument controls how to end the stream. + + ``zstandard.COMPRESSOBJ_FLUSH_FINISH`` (the default) ends the + compression stream and finishes a zstd frame. Once this type of flush + is performed, ``compress()`` and ``flush()`` can no longer be called. + This type of flush **must** be called to end the compression context. If + not called, the emitted data may be incomplete and may not be readable + by a decompressor. + + ``zstandard.COMPRESSOBJ_FLUSH_BLOCK`` will flush a zstd block. This + ensures that all data fed to this instance will have been omitted and + can be decoded by a decompressor. Flushes of this type can be performed + multiple times. The next call to ``compress()`` will begin a new zstd + block. + + :param flush_mode: + How to flush the zstd compressor. + :return: + Compressed data. + """ + 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): + """Compress data to uniformly sized chunks. + + This type allows you to iteratively feed chunks of data into a compressor + and produce output chunks of uniform size. + + ``compress()``, ``flush()``, and ``finish()`` all return an iterator of + ``bytes`` instances holding compressed data. The iterator may be empty. + Callers MUST iterate through all elements of the returned iterator before + performing another operation on the object or else the compressor's + internal state may become confused. This can result in an exception being + raised or malformed data being emitted. + + All chunks emitted by ``compress()`` will have a length of the configured + chunk size. + + ``flush()`` and ``finish()`` may return a final chunk smaller than + the configured chunk size. + + Instances are obtained by calling :py:meth:`ZstdCompressor.chunker`. + + Here is how the API should be used: + + >>> cctx = zstandard.ZstdCompressor() + >>> chunker = cctx.chunker(chunk_size=32768) + >>> + >>> with open(path, 'rb') as fh: + ... while True: + ... in_chunk = fh.read(32768) + ... if not in_chunk: + ... break + ... + ... for out_chunk in chunker.compress(in_chunk): + ... # Do something with output chunk of size 32768. + ... + ... for out_chunk in chunker.finish(): + ... # Do something with output chunks that finalize the zstd frame. + + This compressor type is often a better alternative to + :py:class:`ZstdCompressor.compressobj` because it has better performance + properties. + + ``compressobj()`` will emit output data as it is available. This results + in a *stream* of output chunks of varying sizes. The consistency of the + output chunk size with ``chunker()`` is more appropriate for many usages, + such as sending compressed data to a socket. + + ``compressobj()`` may also perform extra memory reallocations in order + to dynamically adjust the sizes of the output chunks. Since ``chunker()`` + output chunks are all the same size (except for flushed or final chunks), + there is less memory allocation/copying overhead. + """ + + 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): + """Feed new input data into the compressor. + + :param data: + Data to feed to compressor. + :return: + Iterator of ``bytes`` representing chunks of compressed data. + """ + if self._finished: + raise ZstdError("cannot call compress() after compression finished") + + if self._in.src != ffi.NULL: + raise ZstdError( + "cannot perform operation before consuming output " + "from previous operation" + ) + + data_buffer = ffi.from_buffer(data) + + if not len(data_buffer): + return + + self._in.src = data_buffer + self._in.size = len(data_buffer) + self._in.pos = 0 + + while self._in.pos < self._in.size: + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, self._out, self._in, lib.ZSTD_e_continue + ) + + if self._in.pos == self._in.size: + self._in.src = ffi.NULL + self._in.size = 0 + self._in.pos = 0 + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if self._out.pos == self._out.size: + yield ffi.buffer(self._out.dst, self._out.pos)[:] + self._out.pos = 0 + + def flush(self): + """Flushes all data currently in the compressor. + + :return: + Iterator of ``bytes`` of compressed data. + """ + if self._finished: + raise ZstdError("cannot call flush() after compression finished") + + if self._in.src != ffi.NULL: + raise ZstdError( + "cannot call flush() before consuming output from " + "previous operation" + ) + + while True: + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, self._out, self._in, lib.ZSTD_e_flush + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if self._out.pos: + yield ffi.buffer(self._out.dst, self._out.pos)[:] + self._out.pos = 0 + + if not zresult: + return + + def finish(self): + """Signals the end of input data. + + No new data can be compressed after this method is called. + + This method will flush buffered data and finish the zstd frame. + + :return: + Iterator of ``bytes`` of compressed data. + """ + if self._finished: + raise ZstdError("cannot call finish() after compression finished") + + if self._in.src != ffi.NULL: + raise ZstdError( + "cannot call finish() before consuming output from " + "previous operation" + ) + + while True: + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, self._out, self._in, lib.ZSTD_e_end + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if self._out.pos: + yield ffi.buffer(self._out.dst, self._out.pos)[:] + self._out.pos = 0 + + if not zresult: + self._finished = True + return + + +class ZstdCompressionReader(object): + """Readable compressing stream wrapper. + + ``ZstdCompressionReader`` is a read-only stream interface for obtaining + compressed data from a source. + + This type conforms to the ``io.RawIOBase`` interface and should be usable + by any type that operates against a *file-object* (``typing.BinaryIO`` + in Python type hinting speak). + + Instances are neither writable nor seekable (even if the underlying + source is seekable). ``readline()`` and ``readlines()`` are not implemented + because they don't make sense for compressed data. ``tell()`` returns the + number of compressed bytes emitted so far. + + Instances are obtained by calling :py:meth:`ZstdCompressor.stream_reader`. + + In this example, we open a file for reading and then wrap that file + handle with a stream from which compressed data can be ``read()``. + + >>> with open(path, 'rb') as fh: + ... cctx = zstandard.ZstdCompressor() + ... reader = cctx.stream_reader(fh) + ... while True: + ... chunk = reader.read(16384) + ... if not chunk: + ... break + ... + ... # Do something with compressed chunk. + + Instances can also be used as context managers: + + >>> with open(path, 'rb') as fh: + ... cctx = zstandard.ZstdCompressor() + ... with cctx.stream_reader(fh) as reader: + ... while True: + ... chunk = reader.read(16384) + ... if not chunk: + ... break + ... + ... # Do something with compressed chunk. + + When the context manager exits or ``close()`` is called, the stream is + closed, underlying resources are released, and future operations against + the compression stream will fail. + + ``stream_reader()`` accepts a ``size`` argument specifying how large the + input stream is. This is used to adjust compression parameters so they are + tailored to the source size. e.g. + + >>> with open(path, 'rb') as fh: + ... cctx = zstandard.ZstdCompressor() + ... with cctx.stream_reader(fh, size=os.stat(path).st_size) as reader: + ... ... + + If the ``source`` is a stream, you can specify how large ``read()`` + requests to that stream should be via the ``read_size`` argument. + It defaults to ``zstandard.COMPRESSION_RECOMMENDED_INPUT_SIZE``. e.g. + + >>> with open(path, 'rb') as fh: + ... cctx = zstandard.ZstdCompressor() + ... # Will perform fh.read(8192) when obtaining data to feed into the + ... # compressor. + ... with cctx.stream_reader(fh, read_size=8192) as reader: + ... ... + """ + + def __init__(self, compressor, source, read_size, closefd=True): + self._compressor = compressor + self._source = source + self._read_size = read_size + self._closefd = closefd + 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") + + if self._closed: + raise ValueError("stream is closed") + + self._entered = True + return self + + def __exit__(self, exc_type, exc_value, exc_tb): + self._entered = False + self._compressor = None + self.close() + self._source = 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): + if self._closed: + return + + self._closed = True + + f = getattr(self._source, "close", None) + if self._closefd and f: + f() + + @property + def closed(self): + return self._closed + + def tell(self): + return self._bytes_compressed + + def readall(self): + chunks = [] + + while True: + chunk = self.read(1048576) + if not chunk: + break + + chunks.append(chunk) + + return b"".join(chunks) + + def __iter__(self): + raise io.UnsupportedOperation() + + def __next__(self): + raise io.UnsupportedOperation() + + next = __next__ + + def _read_input(self): + if self._finished_input: + return + + if hasattr(self._source, "read"): + data = self._source.read(self._read_size) + + if not data: + self._finished_input = True + return + + self._source_buffer = ffi.from_buffer(data) + self._in_buffer.src = self._source_buffer + self._in_buffer.size = len(self._source_buffer) + self._in_buffer.pos = 0 + else: + self._source_buffer = ffi.from_buffer(self._source) + self._in_buffer.src = self._source_buffer + self._in_buffer.size = len(self._source_buffer) + self._in_buffer.pos = 0 + + def _compress_into_buffer(self, out_buffer): + if self._in_buffer.pos >= self._in_buffer.size: + return + + old_pos = out_buffer.pos + + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, + out_buffer, + self._in_buffer, + lib.ZSTD_e_continue, + ) + + self._bytes_compressed += out_buffer.pos - old_pos + + if self._in_buffer.pos == self._in_buffer.size: + self._in_buffer.src = ffi.NULL + self._in_buffer.pos = 0 + self._in_buffer.size = 0 + self._source_buffer = None + + if not hasattr(self._source, "read"): + self._finished_input = True + + if lib.ZSTD_isError(zresult): + raise ZstdError("zstd compress error: %s", _zstd_error(zresult)) + + return out_buffer.pos and out_buffer.pos == out_buffer.size + + def read(self, size=-1): + if self._closed: + raise ValueError("stream is closed") + + if size < -1: + raise ValueError("cannot read negative amounts less than -1") + + if size == -1: + return self.readall() + + if self._finished_output or size == 0: + return b"" + + # Need a dedicated ref to dest buffer otherwise it gets collected. + dst_buffer = ffi.new("char[]", size) + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = dst_buffer + out_buffer.size = size + out_buffer.pos = 0 + + if self._compress_into_buffer(out_buffer): + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + while not self._finished_input: + self._read_input() + + if self._compress_into_buffer(out_buffer): + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + # EOF + old_pos = out_buffer.pos + + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, out_buffer, self._in_buffer, lib.ZSTD_e_end + ) + + self._bytes_compressed += out_buffer.pos - old_pos + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s", _zstd_error(zresult) + ) + + if zresult == 0: + self._finished_output = True + + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + def read1(self, size=-1): + if self._closed: + raise ValueError("stream is closed") + + if size < -1: + raise ValueError("cannot read negative amounts less than -1") + + if self._finished_output or size == 0: + return b"" + + # -1 returns arbitrary number of bytes. + if size == -1: + size = COMPRESSION_RECOMMENDED_OUTPUT_SIZE + + dst_buffer = ffi.new("char[]", size) + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = dst_buffer + out_buffer.size = size + out_buffer.pos = 0 + + # read1() dictates that we can perform at most 1 call to the + # underlying stream to get input. However, we can't satisfy this + # restriction with compression because not all input generates output. + # It is possible to perform a block flush in order to ensure output. + # But this may not be desirable behavior. So we allow multiple read() + # to the underlying stream. But unlike read(), we stop once we have + # any output. + + self._compress_into_buffer(out_buffer) + if out_buffer.pos: + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + while not self._finished_input: + self._read_input() + + # If we've filled the output buffer, return immediately. + if self._compress_into_buffer(out_buffer): + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + # If we've populated the output buffer and we're not at EOF, + # also return, as we've satisfied the read1() limits. + if out_buffer.pos and not self._finished_input: + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + # Else if we're at EOS and we have room left in the buffer, + # fall through to below and try to add more data to the output. + + # EOF. + old_pos = out_buffer.pos + + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, out_buffer, self._in_buffer, lib.ZSTD_e_end + ) + + self._bytes_compressed += out_buffer.pos - old_pos + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s" % _zstd_error(zresult) + ) + + if zresult == 0: + self._finished_output = True + + return ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + + def readinto(self, b): + if self._closed: + raise ValueError("stream is closed") + + if self._finished_output: + return 0 + + # TODO use writable=True once we require CFFI >= 1.12. + dest_buffer = ffi.from_buffer(b) + ffi.memmove(b, b"", 0) + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = dest_buffer + out_buffer.size = len(dest_buffer) + out_buffer.pos = 0 + + if self._compress_into_buffer(out_buffer): + return out_buffer.pos + + while not self._finished_input: + self._read_input() + if self._compress_into_buffer(out_buffer): + return out_buffer.pos + + # EOF. + old_pos = out_buffer.pos + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, out_buffer, self._in_buffer, lib.ZSTD_e_end + ) + + self._bytes_compressed += out_buffer.pos - old_pos + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s", _zstd_error(zresult) + ) + + if zresult == 0: + self._finished_output = True + + return out_buffer.pos + + def readinto1(self, b): + if self._closed: + raise ValueError("stream is closed") + + if self._finished_output: + return 0 + + # TODO use writable=True once we require CFFI >= 1.12. + dest_buffer = ffi.from_buffer(b) + ffi.memmove(b, b"", 0) + + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = dest_buffer + out_buffer.size = len(dest_buffer) + out_buffer.pos = 0 + + self._compress_into_buffer(out_buffer) + if out_buffer.pos: + return out_buffer.pos + + while not self._finished_input: + self._read_input() + + if self._compress_into_buffer(out_buffer): + return out_buffer.pos + + if out_buffer.pos and not self._finished_input: + return out_buffer.pos + + # EOF. + old_pos = out_buffer.pos + + zresult = lib.ZSTD_compressStream2( + self._compressor._cctx, out_buffer, self._in_buffer, lib.ZSTD_e_end + ) + + self._bytes_compressed += out_buffer.pos - old_pos + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s" % _zstd_error(zresult) + ) + + if zresult == 0: + self._finished_output = True + + return out_buffer.pos + + +class ZstdCompressor(object): + """ + Create an object used to perform Zstandard compression. + + Each instance is essentially a wrapper around a ``ZSTD_CCtx`` from + zstd's C API. + + An instance can compress data various ways. Instances can be used + multiple times. Each compression operation will use the compression + parameters defined at construction time. + + .. note: + + When using a compression dictionary and multiple compression + operations are performed, the ``ZstdCompressionParameters`` derived + from an integer compression ``level`` and the first compressed data's + size will be reused for all subsequent operations. This may not be + desirable if source data sizes vary significantly. + + ``compression_params`` is mutually exclusive with ``level``, + ``write_checksum``, ``write_content_size``, ``write_dict_id``, and + ``threads``. + + Assume that each ``ZstdCompressor`` instance can only handle a single + logical compression operation at the same time. i.e. if you call a method + like ``stream_reader()`` to obtain multiple objects derived from the same + ``ZstdCompressor`` instance and attempt to use them simultaneously, errors + will likely occur. + + If you need to perform multiple logical compression operations and you + can't guarantee those operations are temporally non-overlapping, you need + to obtain multiple ``ZstdCompressor`` instances. + + Unless specified otherwise, assume that no two methods of + ``ZstdCompressor`` instances can be called from multiple Python + threads simultaneously. In other words, assume instances are not thread safe + unless stated otherwise. + + :param level: + Integer compression level. Valid values are all negative integers + through 22. Lower values generally yield faster operations with lower + compression ratios. Higher values are generally slower but compress + better. The default is 3, which is what the ``zstd`` CLI uses. Negative + levels effectively engage ``--fast`` mode from the ``zstd`` CLI. + :param dict_data: + A ``ZstdCompressionDict`` to be used to compress with dictionary + data. + :param compression_params: + A ``ZstdCompressionParameters`` instance defining low-level compression + parameters. If defined, this will overwrite the ``level`` argument. + :param write_checksum: + If True, a 4 byte content checksum will be written with the compressed + data, allowing the decompressor to perform content verification. + :param write_content_size: + If True (the default), the decompressed content size will be included + in the header of the compressed data. This data will only be written if + the compressor knows the size of the input data. + :param write_dict_id: + Determines whether the dictionary ID will be written into the compressed + data. Defaults to True. Only adds content to the compressed data if + a dictionary is being used. + :param threads: + Number of threads to use to compress data concurrently. When set, + compression operations are performed on multiple threads. The default + value (0) disables multi-threaded compression. A value of ``-1`` means + to set the number of threads to the number of detected logical CPUs. + """ + + def __init__( + self, + level=3, + dict_data=None, + compression_params=None, + write_checksum=None, + write_content_size=None, + write_dict_id=None, + threads=0, + ): + if level > lib.ZSTD_maxCLevel(): + raise ValueError( + "level must be less than %d" % lib.ZSTD_maxCLevel() + ) + + if threads < 0: + threads = _cpu_count() + + if compression_params and write_checksum is not None: + raise ValueError( + "cannot define compression_params and write_checksum" + ) + + if compression_params and write_content_size is not None: + raise ValueError( + "cannot define compression_params and write_content_size" + ) + + if compression_params and write_dict_id is not None: + raise ValueError( + "cannot define compression_params and write_dict_id" + ) + + if compression_params and threads: + raise ValueError("cannot define compression_params and threads") + + if compression_params: + self._params = _make_cctx_params(compression_params) + else: + if write_dict_id is None: + write_dict_id = True + + params = lib.ZSTD_createCCtxParams() + if params == ffi.NULL: + raise MemoryError() + + self._params = ffi.gc(params, lib.ZSTD_freeCCtxParams) + + _set_compression_parameter( + self._params, lib.ZSTD_c_compressionLevel, level + ) + + _set_compression_parameter( + self._params, + lib.ZSTD_c_contentSizeFlag, + write_content_size if write_content_size is not None else 1, + ) + + _set_compression_parameter( + self._params, + lib.ZSTD_c_checksumFlag, + 1 if write_checksum else 0, + ) + + _set_compression_parameter( + self._params, lib.ZSTD_c_dictIDFlag, 1 if write_dict_id else 0 + ) + + if threads: + _set_compression_parameter( + self._params, lib.ZSTD_c_nbWorkers, threads + ) + + cctx = lib.ZSTD_createCCtx() + if cctx == ffi.NULL: + raise MemoryError() + + self._cctx = cctx + self._dict_data = dict_data + + # We defer setting up garbage collection until after calling + # _setup_cctx() to ensure the memory size estimate is more accurate. + try: + self._setup_cctx() + finally: + self._cctx = ffi.gc( + cctx, lib.ZSTD_freeCCtx, size=lib.ZSTD_sizeof_CCtx(cctx) + ) + + def _setup_cctx(self): + zresult = lib.ZSTD_CCtx_setParametersUsingCCtxParams( + self._cctx, self._params + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "could not set compression parameters: %s" + % _zstd_error(zresult) + ) + + dict_data = self._dict_data + + if dict_data: + if dict_data._cdict: + zresult = lib.ZSTD_CCtx_refCDict(self._cctx, dict_data._cdict) + else: + zresult = lib.ZSTD_CCtx_loadDictionary_advanced( + self._cctx, + dict_data.as_bytes(), + len(dict_data), + lib.ZSTD_dlm_byRef, + dict_data._dict_type, + ) + + if lib.ZSTD_isError(zresult): + raise ZstdError( + "could not load compression dictionary: %s" + % _zstd_error(zresult) + ) + + def memory_size(self): + """Obtain the memory usage of this compressor, in bytes. + + >>> cctx = zstandard.ZstdCompressor() + >>> memory = cctx.memory_size() + """ + return lib.ZSTD_sizeof_CCtx(self._cctx) + + def compress(self, data): + """ + Compress data in a single operation. + + This is the simplest mechanism to perform compression: simply pass in a + value and get a compressed value back. It is almost the most prone to + abuse. + + The input and output values must fit in memory, so passing in very large + values can result in excessive memory usage. For this reason, one of the + streaming based APIs is preferred for larger values. + + :param data: + Source data to compress + :return: + Compressed data + + >>> cctx = zstandard.ZstdCompressor() + >>> compressed = cctx.compress(b"data to compress") + """ + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + data_buffer = ffi.from_buffer(data) + + dest_size = lib.ZSTD_compressBound(len(data_buffer)) + out = new_nonzero("char[]", dest_size) + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, len(data_buffer)) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + out_buffer = ffi.new("ZSTD_outBuffer *") + in_buffer = ffi.new("ZSTD_inBuffer *") + + out_buffer.dst = out + out_buffer.size = dest_size + out_buffer.pos = 0 + + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + zresult = lib.ZSTD_compressStream2( + self._cctx, out_buffer, in_buffer, lib.ZSTD_e_end + ) + + if lib.ZSTD_isError(zresult): + raise ZstdError("cannot compress: %s" % _zstd_error(zresult)) + elif zresult: + raise ZstdError("unexpected partial frame flush") + + return ffi.buffer(out, out_buffer.pos)[:] + + def compressobj(self, size=-1): + """ + Obtain a compressor exposing the Python standard library compression API. + + See :py:class:`ZstdCompressionObj` for the full documentation. + + :param size: + Size in bytes of data that will be compressed. + :return: + :py:class:`ZstdCompressionObj` + """ + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + if size < 0: + size = lib.ZSTD_CONTENTSIZE_UNKNOWN + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + cobj = ZstdCompressionObj(self, COMPRESSION_RECOMMENDED_OUTPUT_SIZE) + + return cobj + + def chunker(self, size=-1, chunk_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE): + """ + Create an object for iterative compressing to same-sized chunks. + + This API is similar to :py:meth:`ZstdCompressor.compressobj` but has + better performance properties. + + :param size: + Size in bytes of data that will be compressed. + :param chunk_size: + Size of compressed chunks. + :return: + :py:class:`ZstdCompressionChunker` + """ + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + if size < 0: + size = lib.ZSTD_CONTENTSIZE_UNKNOWN + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + return ZstdCompressionChunker(self, chunk_size=chunk_size) + + def copy_stream( + self, + ifh, + ofh, + size=-1, + read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE, + write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE, + ): + """ + Copy data between 2 streams while compressing it. + + Data will be read from ``ifh``, compressed, and written to ``ofh``. + ``ifh`` must have a ``read(size)`` method. ``ofh`` must have a + ``write(data)`` + method. + + >>> cctx = zstandard.ZstdCompressor() + >>> with open(input_path, "rb") as ifh, open(output_path, "wb") as ofh: + ... cctx.copy_stream(ifh, ofh) + + It is also possible to declare the size of the source stream: + + >>> cctx = zstandard.ZstdCompressor() + >>> cctx.copy_stream(ifh, ofh, size=len_of_input) + + You can also specify how large the chunks that are ``read()`` + and ``write()`` from and to the streams: + + >>> cctx = zstandard.ZstdCompressor() + >>> cctx.copy_stream(ifh, ofh, read_size=32768, write_size=16384) + + The stream copier returns a 2-tuple of bytes read and written: + + >>> cctx = zstandard.ZstdCompressor() + >>> read_count, write_count = cctx.copy_stream(ifh, ofh) + + :param ifh: + Source stream to read from + :param ofh: + Destination stream to write to + :param size: + Size in bytes of the source stream. If defined, compression + parameters will be tuned for this size. + :param read_size: + Chunk sizes that source stream should be ``read()`` from. + :param write_size: + Chunk sizes that destination stream should be ``write()`` to. + :return: + 2-tuple of ints of bytes read and written, respectively. + """ + + if not hasattr(ifh, "read"): + raise ValueError("first argument must have a read() method") + if not hasattr(ofh, "write"): + raise ValueError("second argument must have a write() method") + + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + if size < 0: + size = lib.ZSTD_CONTENTSIZE_UNKNOWN + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + in_buffer = ffi.new("ZSTD_inBuffer *") + out_buffer = ffi.new("ZSTD_outBuffer *") + + dst_buffer = ffi.new("char[]", write_size) + out_buffer.dst = dst_buffer + out_buffer.size = write_size + out_buffer.pos = 0 + + total_read, total_write = 0, 0 + + while True: + data = ifh.read(read_size) + if not data: + break + + data_buffer = ffi.from_buffer(data) + total_read += len(data_buffer) + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + while in_buffer.pos < in_buffer.size: + zresult = lib.ZSTD_compressStream2( + self._cctx, out_buffer, in_buffer, lib.ZSTD_e_continue + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) + total_write += out_buffer.pos + out_buffer.pos = 0 + + # We've finished reading. Flush the compressor. + while True: + zresult = lib.ZSTD_compressStream2( + self._cctx, out_buffer, in_buffer, lib.ZSTD_e_end + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) + total_write += out_buffer.pos + out_buffer.pos = 0 + + if zresult == 0: + break + + return total_read, total_write + + def stream_reader( + self, + source, + size=-1, + read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE, + closefd=True, + ): + """ + Wrap a readable source with a stream that can read compressed data. + + This will produce an object conforming to the ``io.RawIOBase`` + interface which can be ``read()`` from to retrieve compressed data + from a source. + + The source object can be any object with a ``read(size)`` method + or an object that conforms to the buffer protocol. + + See :py:class:`ZstdCompressionReader` for type documentation and usage + examples. + + :param source: + Object to read source data from + :param size: + Size in bytes of source object. + :param read_size: + How many bytes to request when ``read()``'ing from the source. + :param closefd: + Whether to close the source stream when the returned stream is + closed. + :return: + :py:class:`ZstdCompressionReader` + """ + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + try: + size = len(source) + except Exception: + pass + + if size < 0: + size = lib.ZSTD_CONTENTSIZE_UNKNOWN + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + return ZstdCompressionReader(self, source, read_size, closefd=closefd) + + def stream_writer( + self, + writer, + size=-1, + write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE, + write_return_read=True, + closefd=True, + ): + """ + Create a stream that will write compressed data into another stream. + + The argument to ``stream_writer()`` must have a ``write(data)`` method. + As compressed data is available, ``write()`` will be called with the + compressed data as its argument. Many common Python types implement + ``write()``, including open file handles and ``io.BytesIO``. + + See :py:class:`ZstdCompressionWriter` for more documentation, including + usage examples. + + :param writer: + Stream to write compressed data to. + :param size: + Size in bytes of data to be compressed. If set, it will be used + to influence compression parameter tuning and could result in the + size being written into the header of the compressed data. + :param write_size: + How much data to ``write()`` to ``writer`` at a time. + :param write_return_read: + Whether ``write()`` should return the number of bytes that were + consumed from the input. + :param closefd: + Whether to ``close`` the ``writer`` when this stream is closed. + :return: + :py:class:`ZstdCompressionWriter` + """ + 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, closefd=closefd + ) + + def read_to_iter( + self, + reader, + size=-1, + read_size=COMPRESSION_RECOMMENDED_INPUT_SIZE, + write_size=COMPRESSION_RECOMMENDED_OUTPUT_SIZE, + ): + """ + Read uncompressed data from a reader and return an iterator + + Returns an iterator of compressed data produced from reading from + ``reader``. + + This method provides a mechanism to stream compressed data out of a + source as an iterator of data chunks. + + Uncompressed data will be obtained from ``reader`` by calling the + ``read(size)`` method of it or by reading a slice (if ``reader`` + conforms to the *buffer protocol*). The source data will be streamed + into a compressor. As compressed data is available, it will be exposed + to the iterator. + + Data is read from the source in chunks of ``read_size``. Compressed + chunks are at most ``write_size`` bytes. Both values default to the + zstd input and and output defaults, respectively. + + If reading from the source via ``read()``, ``read()`` will be called + until it raises or returns an empty bytes (``b""``). It is perfectly + valid for the source to deliver fewer bytes than were what requested + by ``read(size)``. + + The caller is partially in control of how fast data is fed into the + compressor by how it consumes the returned iterator. The compressor + will not consume from the reader unless the caller consumes from the + iterator. + + >>> cctx = zstandard.ZstdCompressor() + >>> for chunk in cctx.read_to_iter(fh): + ... # Do something with emitted data. + + ``read_to_iter()`` accepts a ``size`` argument declaring the size of + the input stream: + + >>> cctx = zstandard.ZstdCompressor() + >>> for chunk in cctx.read_to_iter(fh, size=some_int): + >>> pass + + You can also control the size that data is ``read()`` from the source + and the ideal size of output chunks: + + >>> cctx = zstandard.ZstdCompressor() + >>> for chunk in cctx.read_to_iter(fh, read_size=16384, write_size=8192): + >>> pass + + ``read_to_iter()`` does not give direct control over the sizes of chunks + fed into the compressor. Instead, chunk sizes will be whatever the object + being read from delivers. These will often be of a uniform size. + + :param reader: + Stream providing data to be compressed. + :param size: + Size in bytes of input data. + :param read_size: + Controls how many bytes are ``read()`` from the source. + :param write_size: + Controls the output size of emitted chunks. + :return: + Iterator of ``bytes``. + """ + + if hasattr(reader, "read"): + have_read = True + elif hasattr(reader, "__getitem__"): + have_read = False + buffer_offset = 0 + size = len(reader) + else: + raise ValueError( + "must pass an object with a read() method or " + "conforms to buffer protocol" + ) + + lib.ZSTD_CCtx_reset(self._cctx, lib.ZSTD_reset_session_only) + + if size < 0: + size = lib.ZSTD_CONTENTSIZE_UNKNOWN + + zresult = lib.ZSTD_CCtx_setPledgedSrcSize(self._cctx, size) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error setting source size: %s" % _zstd_error(zresult) + ) + + in_buffer = ffi.new("ZSTD_inBuffer *") + out_buffer = ffi.new("ZSTD_outBuffer *") + + in_buffer.src = ffi.NULL + in_buffer.size = 0 + in_buffer.pos = 0 + + dst_buffer = ffi.new("char[]", write_size) + out_buffer.dst = dst_buffer + out_buffer.size = write_size + out_buffer.pos = 0 + + while True: + # We should never have output data sitting around after a previous + # iteration. + assert out_buffer.pos == 0 + + # Collect input data. + if have_read: + read_result = reader.read(read_size) + else: + remaining = len(reader) - buffer_offset + slice_size = min(remaining, read_size) + read_result = reader[buffer_offset : buffer_offset + slice_size] + buffer_offset += slice_size + + # No new input data. Break out of the read loop. + if not read_result: + break + + # Feed all read data into the compressor and emit output until + # exhausted. + read_buffer = ffi.from_buffer(read_result) + in_buffer.src = read_buffer + in_buffer.size = len(read_buffer) + in_buffer.pos = 0 + + while in_buffer.pos < in_buffer.size: + zresult = lib.ZSTD_compressStream2( + self._cctx, out_buffer, in_buffer, lib.ZSTD_e_continue + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd compress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + out_buffer.pos = 0 + yield data + + assert out_buffer.pos == 0 + + # And repeat the loop to collect more data. + continue + + # If we get here, input is exhausted. End the stream and emit what + # remains. + while True: + assert out_buffer.pos == 0 + zresult = lib.ZSTD_compressStream2( + self._cctx, out_buffer, in_buffer, lib.ZSTD_e_end + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "error ending compression stream: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + out_buffer.pos = 0 + yield data + + if zresult == 0: + break + + def multi_compress_to_buffer(self, data, threads=-1): + """ + Compress multiple pieces of data as a single function call. + + (Experimental. Not yet supported by CFFI backend.) + + This function is optimized to perform multiple compression operations + as as possible with as little overhead as possible. + + Data to be compressed can be passed as a ``BufferWithSegmentsCollection``, + a ``BufferWithSegments``, or a list containing byte like objects. Each + element of the container will be compressed individually using the + configured parameters on the ``ZstdCompressor`` instance. + + The ``threads`` argument controls how many threads to use for + compression. The default is ``0`` which means to use a single thread. + Negative values use the number of logical CPUs in the machine. + + The function returns a ``BufferWithSegmentsCollection``. This type + represents N discrete memory allocations, each holding 1 or more + compressed frames. + + Output data is written to shared memory buffers. This means that unlike + regular Python objects, a reference to *any* object within the collection + keeps the shared buffer and therefore memory backing it alive. This can + have undesirable effects on process memory usage. + + The API and behavior of this function is experimental and will likely + change. Known deficiencies include: + + * If asked to use multiple threads, it will always spawn that many + threads, even if the input is too small to use them. It should + automatically lower the thread count when the extra threads would + just add overhead. + * The buffer allocation strategy is fixed. There is room to make it + dynamic, perhaps even to allow one output buffer per input, + facilitating a variation of the API to return a list without the + adverse effects of shared memory buffers. + + :param data: + Source to read discrete pieces of data to compress. + + Can be a ``BufferWithSegmentsCollection``, a ``BufferWithSegments``, + or a ``list[bytes]``. + :return: + BufferWithSegmentsCollection holding compressed data. + """ + raise NotImplementedError() + + def frame_progression(self): + """ + Return information on how much work the compressor has done. + + Returns a 3-tuple of (ingested, consumed, produced). + + >>> cctx = zstandard.ZstdCompressor() + >>> (ingested, consumed, produced) = cctx.frame_progression() + """ + progression = lib.ZSTD_getFrameProgression(self._cctx) + + return progression.ingested, progression.consumed, progression.produced + + +class FrameParameters(object): + """Information about a zstd frame. + + Instances have the following attributes: + + ``content_size`` + Integer size of original, uncompressed content. This will be ``0`` if the + original content size isn't written to the frame (controlled with the + ``write_content_size`` argument to ``ZstdCompressor``) or if the input + content size was ``0``. + + ``window_size`` + Integer size of maximum back-reference distance in compressed data. + + ``dict_id`` + Integer of dictionary ID used for compression. ``0`` if no dictionary + ID was used or if the dictionary ID was ``0``. + + ``has_checksum`` + Bool indicating whether a 4 byte content checksum is stored at the end + of the frame. + """ + + 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): + """Obtain the decompressed size of a frame. + + The returned value is usually accurate. But strictly speaking it should + not be trusted. + + :return: + ``-1`` if size unknown and a non-negative integer otherwise. + """ + 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): + """Obtain the size of a frame header. + + :return: + Integer size in bytes. + """ + 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, format=FORMAT_ZSTD1): + """ + Parse a zstd frame header into frame parameters. + + Depending on which fields are present in the frame and their values, the + length of the frame parameters varies. If insufficient bytes are passed + in to fully parse the frame parameters, ``ZstdError`` is raised. To ensure + frame parameters can be parsed, pass in at least 18 bytes. + + :param data: + Data from which to read frame parameters. + :param format: + Set the format of data for the decoder. + :return: + :py:class:`FrameParameters` + """ + params = ffi.new("ZSTD_FrameHeader *") + + data_buffer = ffi.from_buffer(data) + zresult = lib.ZSTD_getFrameHeader_advanced( + params, data_buffer, len(data_buffer), format + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "cannot get frame parameters: %s" % _zstd_error(zresult) + ) + + if zresult: + raise ZstdError( + "not enough data for frame parameters; need %d bytes" % zresult + ) + + return FrameParameters(params[0]) + + +class ZstdCompressionDict(object): + """Represents a computed compression dictionary. + + Instances are obtained by calling :py:func:`train_dictionary` or by + passing bytes obtained from another source into the constructor. + + Instances can be constructed from bytes: + + >>> dict_data = zstandard.ZstdCompressionDict(data) + + It is possible to construct a dictionary from *any* data. If the data + doesn't begin with a magic header, it will be treated as a *prefix* + dictionary. *Prefix* dictionaries allow compression operations to + reference raw data within the dictionary. + + It is possible to force the use of *prefix* dictionaries or to require + a dictionary header: + + >>> dict_data = zstandard.ZstdCompressionDict(data, dict_type=zstandard.DICT_TYPE_RAWCONTENT) + >>> dict_data = zstandard.ZstdCompressionDict(data, dict_type=zstandard.DICT_TYPE_FULLDICT) + + You can see how many bytes are in the dictionary by calling ``len()``: + + >>> dict_data = zstandard.train_dictionary(size, samples) + >>> dict_size = len(dict_data) # will not be larger than ``size`` + + Once you have a dictionary, you can pass it to the objects performing + compression and decompression: + + >>> dict_data = zstandard.train_dictionary(131072, samples) + >>> cctx = zstandard.ZstdCompressor(dict_data=dict_data) + >>> for source_data in input_data: + ... compressed = cctx.compress(source_data) + ... # Do something with compressed data. + ... + >>> dctx = zstandard.ZstdDecompressor(dict_data=dict_data) + >>> for compressed_data in input_data: + ... buffer = io.BytesIO() + ... with dctx.stream_writer(buffer) as decompressor: + ... decompressor.write(compressed_data) + ... # Do something with raw data in ``buffer``. + + Dictionaries have unique integer IDs. You can retrieve this ID via: + + >>> dict_id = dict_data.dict_id() + + You can obtain the raw data in the dict (useful for persisting and constructing + a ``ZstdCompressionDict`` later) via ``as_bytes()``: + + >>> dict_data = zstandard.train_dictionary(size, samples) + >>> raw_data = dict_data.as_bytes() + + By default, when a ``ZstdCompressionDict`` is *attached* to a + ``ZstdCompressor``, each ``ZstdCompressor`` performs work to prepare the + dictionary for use. This is fine if only 1 compression operation is being + performed or if the ``ZstdCompressor`` is being reused for multiple operations. + But if multiple ``ZstdCompressor`` instances are being used with the dictionary, + this can add overhead. + + It is possible to *precompute* the dictionary so it can readily be consumed + by multiple ``ZstdCompressor`` instances: + + >>> d = zstandard.ZstdCompressionDict(data) + >>> # Precompute for compression level 3. + >>> d.precompute_compress(level=3) + >>> # Precompute with specific compression parameters. + >>> params = zstandard.ZstdCompressionParameters(...) + >>> d.precompute_compress(compression_params=params) + + .. note:: + + When a dictionary is precomputed, the compression parameters used to + precompute the dictionary overwrite some of the compression parameters + specified to ``ZstdCompressor``. + + :param data: + Dictionary data. + :param dict_type: + Type of dictionary. One of the ``DICT_TYPE_*`` constants. + """ + + def __init__(self, data, dict_type=DICT_TYPE_AUTO, k=0, d=0): + assert isinstance(data, bytes) + self._data = data + self.k = k + self.d = d + + if dict_type not in ( + DICT_TYPE_AUTO, + DICT_TYPE_RAWCONTENT, + DICT_TYPE_FULLDICT, + ): + raise ValueError( + "invalid dictionary load mode: %d; must use " + "DICT_TYPE_* constants" + ) + + self._dict_type = dict_type + self._cdict = None + + def __len__(self): + return len(self._data) + + def dict_id(self): + """Obtain the integer ID of the dictionary.""" + return int(lib.ZDICT_getDictID(self._data, len(self._data))) + + def as_bytes(self): + """Obtain the ``bytes`` representation of the dictionary.""" + return self._data + + def precompute_compress(self, level=0, compression_params=None): + """Precompute a dictionary os it can be used by multiple compressors. + + Calling this method on an instance that will be used by multiple + :py:class:`ZstdCompressor` instances will improve performance. + """ + if level and compression_params: + raise ValueError( + "must only specify one of level or compression_params" + ) + + if not level and not compression_params: + raise ValueError("must specify one of level or compression_params") + + if level: + cparams = lib.ZSTD_getCParams(level, 0, len(self._data)) + else: + cparams = ffi.new("ZSTD_compressionParameters") + cparams.chainLog = compression_params.chain_log + cparams.hashLog = compression_params.hash_log + cparams.minMatch = compression_params.min_match + cparams.searchLog = compression_params.search_log + cparams.strategy = compression_params.strategy + cparams.targetLength = compression_params.target_length + cparams.windowLog = compression_params.window_log + + cdict = lib.ZSTD_createCDict_advanced( + self._data, + len(self._data), + lib.ZSTD_dlm_byRef, + self._dict_type, + cparams, + lib.ZSTD_defaultCMem, + ) + if cdict == ffi.NULL: + raise ZstdError("unable to precompute dictionary") + + self._cdict = ffi.gc( + cdict, lib.ZSTD_freeCDict, size=lib.ZSTD_sizeof_CDict(cdict) + ) + + @property + def _ddict(self): + ddict = lib.ZSTD_createDDict_advanced( + self._data, + len(self._data), + lib.ZSTD_dlm_byRef, + self._dict_type, + lib.ZSTD_defaultCMem, + ) + + if ddict == ffi.NULL: + raise ZstdError("could not create decompression dict") + + ddict = ffi.gc( + ddict, lib.ZSTD_freeDDict, size=lib.ZSTD_sizeof_DDict(ddict) + ) + self.__dict__["_ddict"] = ddict + + return ddict + + +def train_dictionary( + dict_size, + samples, + k=0, + d=0, + f=0, + split_point=0.0, + accel=0, + notifications=0, + dict_id=0, + level=0, + steps=0, + threads=0, +): + """Train a dictionary from sample data using the COVER algorithm. + + A compression dictionary of size ``dict_size`` will be created from the + iterable of ``samples``. The raw dictionary bytes will be returned. + + The dictionary training mechanism is known as *cover*. More details about it + are available in the paper *Effective Construction of Relative Lempel-Ziv + Dictionaries* (authors: Liao, Petri, Moffat, Wirth). + + The cover algorithm takes parameters ``k`` and ``d``. These are the + *segment size* and *dmer size*, respectively. The returned dictionary + instance created by this function has ``k`` and ``d`` attributes + containing the values for these parameters. If a ``ZstdCompressionDict`` + is constructed from raw bytes data (a content-only dictionary), the + ``k`` and ``d`` attributes will be ``0``. + + The segment and dmer size parameters to the cover algorithm can either be + specified manually or ``train_dictionary()`` can try multiple values + and pick the best one, where *best* means the smallest compressed data size. + This later mode is called *optimization* mode. + + Under the hood, this function always calls + ``ZDICT_optimizeTrainFromBuffer_fastCover()``. See the corresponding C library + documentation for more. + + If neither ``steps`` nor ``threads`` is defined, defaults for ``d``, ``steps``, + and ``level`` will be used that are equivalent with what + ``ZDICT_trainFromBuffer()`` would use. + + + :param dict_size: + Target size in bytes of the dictionary to generate. + :param samples: + A list of bytes holding samples the dictionary will be trained from. + :param k: + Segment size : constraint: 0 < k : Reasonable range [16, 2048+] + :param d: + dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] + :param f: + log of size of frequency array : constraint: 0 < f <= 31 : 1 means + default(20) + :param split_point: + Percentage of samples used for training: Only used for optimization. + The first # samples * ``split_point`` samples will be used to training. + The last # samples * (1 - split_point) samples will be used for testing. + 0 means default (0.75), 1.0 when all samples are used for both training + and testing. + :param accel: + Acceleration level: constraint: 0 < accel <= 10. Higher means faster + and less accurate, 0 means default(1). + :param dict_id: + Integer dictionary ID for the produced dictionary. Default is 0, which uses + a random value. + :param steps: + Number of steps through ``k`` values to perform when trying parameter + variations. + :param threads: + Number of threads to use when trying parameter variations. Default is 0, + which means to use a single thread. A negative value can be specified to + use as many threads as there are detected logical CPUs. + :param level: + Integer target compression level when trying parameter variations. + :param notifications: + Controls writing of informational messages to ``stderr``. ``0`` (the + default) means to write nothing. ``1`` writes errors. ``2`` writes + progression info. ``3`` writes more details. And ``4`` writes all info. + """ + + if not isinstance(samples, list): + raise TypeError("samples must be a list") + + if threads < 0: + threads = _cpu_count() + + if not steps and not threads: + d = d or 8 + steps = steps or 4 + level = level or 3 + + 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): + raise ValueError("samples must be bytes") + + sample_len = len(sample) + ffi.memmove(samples_buffer + offset, sample, sample_len) + offset += sample_len + sample_sizes[i] = sample_len + + dict_data = new_nonzero("char[]", dict_size) + + dparams = ffi.new("ZDICT_fastCover_params_t *")[0] + dparams.k = k + dparams.d = d + dparams.f = f + dparams.steps = steps + dparams.nbThreads = threads + dparams.splitPoint = split_point + dparams.accel = accel + dparams.zParams.notificationLevel = notifications + dparams.zParams.dictID = dict_id + dparams.zParams.compressionLevel = level + + zresult = lib.ZDICT_optimizeTrainFromBuffer_fastCover( + ffi.addressof(dict_data), + dict_size, + ffi.addressof(samples_buffer), + ffi.addressof(sample_sizes, 0), + len(samples), + ffi.addressof(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): + """A standard library API compatible decompressor. + + This type implements a compressor that conforms to the API by other + decompressors in Python's standard library. e.g. ``zlib.decompressobj`` + or ``bz2.BZ2Decompressor``. This allows callers to use zstd compression + while conforming to a similar API. + + Compressed data chunks are fed into ``decompress(data)`` and + uncompressed output (or an empty bytes) is returned. Output from + subsequent calls needs to be concatenated to reassemble the full + decompressed byte sequence. + + If ``read_across_frames=False``, each instance is single use: once an + input frame is decoded, ``decompress()`` will raise an exception. If + ``read_across_frames=True``, instances can decode multiple frames. + + >>> dctx = zstandard.ZstdDecompressor() + >>> dobj = dctx.decompressobj() + >>> data = dobj.decompress(compressed_chunk_0) + >>> data = dobj.decompress(compressed_chunk_1) + + By default, calls to ``decompress()`` write output data in chunks of size + ``DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE``. These chunks are concatenated + before being returned to the caller. It is possible to define the size of + these temporary chunks by passing ``write_size`` to ``decompressobj()``: + + >>> dctx = zstandard.ZstdDecompressor() + >>> dobj = dctx.decompressobj(write_size=1048576) + + .. note:: + + Because calls to ``decompress()`` may need to perform multiple + memory (re)allocations, this streaming decompression API isn't as + efficient as other APIs. + """ + + def __init__(self, decompressor, write_size, read_across_frames): + self._decompressor = decompressor + self._write_size = write_size + self._finished = False + self._read_across_frames = read_across_frames + self._unused_input = b"" + + def decompress(self, data): + """Send compressed data to the decompressor and obtain decompressed data. + + :param data: + Data to feed into the decompressor. + :return: + Decompressed bytes. + """ + 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) + ) + + # Always record any output from decompressor. + if out_buffer.pos: + chunks.append(ffi.buffer(out_buffer.dst, out_buffer.pos)[:]) + + # 0 is only seen when a frame is fully decoded *and* fully flushed. + # Behavior depends on whether we're in single or multiple frame + # mode. + if zresult == 0 and not self._read_across_frames: + # Mark the instance as done and make any unconsumed input available + # for retrieval. + self._finished = True + self._decompressor = None + self._unused_input = data[in_buffer.pos : in_buffer.size] + break + elif zresult == 0 and self._read_across_frames: + # We're at the end of a fully flushed frame and we can read more. + # Try to read more if there's any more input. + if in_buffer.pos == in_buffer.size: + break + else: + out_buffer.pos = 0 + + # We're not at the end of the frame *or* we're not fully flushed. + + # The decompressor will write out all the bytes it can to the output + # buffer. So if the output buffer is partially filled and the input + # is exhausted, there's nothing more to write. So we've done all we + # can. + elif ( + in_buffer.pos == in_buffer.size + and out_buffer.pos < out_buffer.size + ): + break + else: + out_buffer.pos = 0 + + return b"".join(chunks) + + def flush(self, length=0): + """Effectively a no-op. + + Implemented for compatibility with the standard library APIs. + + Safe to call at any time. + + :return: + Empty bytes. + """ + return b"" + + @property + def unused_data(self): + """Bytes past the end of compressed data. + + If ``decompress()`` is fed additional data beyond the end of a zstd + frame, this value will be non-empty once ``decompress()`` fully decodes + the input frame. + """ + return self._unused_input + + @property + def unconsumed_tail(self): + """Data that has not yet been fed into the decompressor.""" + return b"" + + @property + def eof(self): + """Whether the end of the compressed data stream has been reached.""" + return self._finished + + +class ZstdDecompressionReader(object): + """Read only decompressor that pull uncompressed data from another stream. + + This type provides a read-only stream interface for performing transparent + decompression from another stream or data source. It conforms to the + ``io.RawIOBase`` interface. Only methods relevant to reading are + implemented. + + >>> with open(path, 'rb') as fh: + >>> dctx = zstandard.ZstdDecompressor() + >>> reader = dctx.stream_reader(fh) + >>> while True: + ... chunk = reader.read(16384) + ... if not chunk: + ... break + ... # Do something with decompressed chunk. + + The stream can also be used as a context manager: + + >>> with open(path, 'rb') as fh: + ... dctx = zstandard.ZstdDecompressor() + ... with dctx.stream_reader(fh) as reader: + ... ... + + When used as a context manager, the stream is closed and the underlying + resources are released when the context manager exits. Future operations + against the stream will fail. + + The ``source`` argument to ``stream_reader()`` can be any object with a + ``read(size)`` method or any object implementing the *buffer protocol*. + + If the ``source`` is a stream, you can specify how large ``read()`` requests + to that stream should be via the ``read_size`` argument. It defaults to + ``zstandard.DECOMPRESSION_RECOMMENDED_INPUT_SIZE``.: + + >>> with open(path, 'rb') as fh: + ... dctx = zstandard.ZstdDecompressor() + ... # Will perform fh.read(8192) when obtaining data for the decompressor. + ... with dctx.stream_reader(fh, read_size=8192) as reader: + ... ... + + Instances are *partially* seekable. Absolute and relative positions + (``SEEK_SET`` and ``SEEK_CUR``) forward of the current position are + allowed. Offsets behind the current read position and offsets relative + to the end of stream are not allowed and will raise ``ValueError`` + if attempted. + + ``tell()`` returns the number of decompressed bytes read so far. + + Not all I/O methods are implemented. Notably missing is support for + ``readline()``, ``readlines()``, and linewise iteration support. This is + because streams operate on binary data - not text data. If you want to + convert decompressed output to text, you can chain an ``io.TextIOWrapper`` + to the stream: + + >>> with open(path, 'rb') as fh: + ... dctx = zstandard.ZstdDecompressor() + ... stream_reader = dctx.stream_reader(fh) + ... text_stream = io.TextIOWrapper(stream_reader, encoding='utf-8') + ... for line in text_stream: + ... ... + """ + + def __init__( + self, + decompressor, + source, + read_size, + read_across_frames, + closefd=True, + ): + self._decompressor = decompressor + self._source = source + self._read_size = read_size + self._read_across_frames = bool(read_across_frames) + self._closefd = bool(closefd) + 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") + + if self._closed: + raise ValueError("stream is closed") + + self._entered = True + return self + + def __exit__(self, exc_type, exc_value, exc_tb): + self._entered = False + self._decompressor = None + self.close() + self._source = None + + return False + + def readable(self): + return True + + def writable(self): + return False + + def seekable(self): + return False + + def readline(self, size=-1): + raise io.UnsupportedOperation() + + def readlines(self, hint=-1): + 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): + if self._closed: + return None + + self._closed = True + + f = getattr(self._source, "close", None) + if self._closefd and f: + f() + + @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 OSError("cannot seek to negative position with SEEK_SET") + + if pos < self._bytes_decompressed: + raise OSError("cannot seek zstd decompression stream backwards") + + read_amount = pos - self._bytes_decompressed + + elif whence == os.SEEK_CUR: + if pos < 0: + raise OSError("cannot seek zstd decompression stream backwards") + + read_amount = pos + elif whence == os.SEEK_END: + raise OSError( + "zstd decompression streams cannot be seeked with SEEK_END" + ) + + while read_amount: + result = self.read( + min(read_amount, DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE) + ) + + if not result: + break + + read_amount -= len(result) + + return self._bytes_decompressed + + +class ZstdDecompressionWriter(object): + """ + Write-only stream wrapper that performs decompression. + + This type provides a writable stream that performs decompression and writes + decompressed data to another stream. + + This type implements the ``io.RawIOBase`` interface. Only methods that + involve writing will do useful things. + + Behavior is similar to :py:meth:`ZstdCompressor.stream_writer`: compressed + data is sent to the decompressor by calling ``write(data)`` and decompressed + output is written to the inner stream by calling its ``write(data)`` + method: + + >>> dctx = zstandard.ZstdDecompressor() + >>> decompressor = dctx.stream_writer(fh) + >>> # Will call fh.write() with uncompressed data. + >>> decompressor.write(compressed_data) + + Instances can be used as context managers. However, context managers add no + extra special behavior other than automatically calling ``close()`` when + they exit. + + Calling ``close()`` will mark the stream as closed and subsequent I/O + operations will raise ``ValueError`` (per the documented behavior of + ``io.RawIOBase``). ``close()`` will also call ``close()`` on the + underlying stream if such a method exists and the instance was created with + ``closefd=True``. + + The size of chunks to ``write()`` to the destination can be specified: + + >>> dctx = zstandard.ZstdDecompressor() + >>> with dctx.stream_writer(fh, write_size=16384) as decompressor: + >>> pass + + You can see how much memory is being used by the decompressor: + + >>> dctx = zstandard.ZstdDecompressor() + >>> with dctx.stream_writer(fh) as decompressor: + >>> byte_size = decompressor.memory_size() + + ``stream_writer()`` accepts a ``write_return_read`` boolean argument to control + the return value of ``write()``. When ``True`` (the default)``, ``write()`` + returns the number of bytes that were read from the input. When ``False``, + ``write()`` returns the number of bytes that were ``write()`` to the inner + stream. + """ + + def __init__( + self, + decompressor, + writer, + write_size, + write_return_read, + closefd=True, + ): + decompressor._ensure_dctx() + + self._decompressor = decompressor + self._writer = writer + self._write_size = write_size + self._write_return_read = bool(write_return_read) + self._closefd = bool(closefd) + self._entered = False + self._closing = 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() + + return False + + def __iter__(self): + raise io.UnsupportedOperation() + + def __next__(self): + raise io.UnsupportedOperation() + + def memory_size(self): + return lib.ZSTD_sizeof_DCtx(self._decompressor._dctx) + + def close(self): + if self._closed: + return + + try: + self._closing = True + self.flush() + finally: + self._closing = False + self._closed = True + + f = getattr(self._writer, "close", None) + if self._closefd and 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 and not self._closing: + return f() + + def isatty(self): + return False + + def readable(self): + return False + + def readline(self, size=-1): + raise io.UnsupportedOperation() + + def readlines(self, hint=-1): + raise io.UnsupportedOperation() + + def seek(self, offset, whence=None): + raise io.UnsupportedOperation() + + def seekable(self): + return False + + def tell(self): + raise io.UnsupportedOperation() + + def truncate(self, size=None): + raise io.UnsupportedOperation() + + def writable(self): + return True + + def writelines(self, lines): + raise io.UnsupportedOperation() + + def read(self, size=-1): + raise io.UnsupportedOperation() + + def readall(self): + raise io.UnsupportedOperation() + + def readinto(self, b): + raise io.UnsupportedOperation() + + def write(self, data): + if self._closed: + raise ValueError("stream is closed") + + total_write = 0 + + in_buffer = ffi.new("ZSTD_inBuffer *") + out_buffer = ffi.new("ZSTD_outBuffer *") + + data_buffer = ffi.from_buffer(data) + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + dst_buffer = ffi.new("char[]", self._write_size) + out_buffer.dst = dst_buffer + out_buffer.size = len(dst_buffer) + out_buffer.pos = 0 + + dctx = self._decompressor._dctx + + while in_buffer.pos < in_buffer.size: + zresult = lib.ZSTD_decompressStream(dctx, out_buffer, in_buffer) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd decompress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + self._writer.write( + ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + ) + total_write += out_buffer.pos + out_buffer.pos = 0 + + if self._write_return_read: + return in_buffer.pos + else: + return total_write + + +class ZstdDecompressor(object): + """ + Context for performing zstandard decompression. + + Each instance is essentially a wrapper around a ``ZSTD_DCtx`` from zstd's + C API. + + An instance can compress data various ways. Instances can be used multiple + times. + + The interface of this class is very similar to + :py:class:`zstandard.ZstdCompressor` (by design). + + Assume that each ``ZstdDecompressor`` instance can only handle a single + logical compression operation at the same time. i.e. if you call a method + like ``decompressobj()`` to obtain multiple objects derived from the same + ``ZstdDecompressor`` instance and attempt to use them simultaneously, errors + will likely occur. + + If you need to perform multiple logical decompression operations and you + can't guarantee those operations are temporally non-overlapping, you need + to obtain multiple ``ZstdDecompressor`` instances. + + Unless specified otherwise, assume that no two methods of + ``ZstdDecompressor`` instances can be called from multiple Python + threads simultaneously. In other words, assume instances are not thread safe + unless stated otherwise. + + :param dict_data: + Compression dictionary to use. + :param max_window_size: + Sets an upper limit on the window size for decompression operations in + kibibytes. This setting can be used to prevent large memory allocations + for inputs using large compression windows. + :param format: + Set the format of data for the decoder. + + By default this is ``zstandard.FORMAT_ZSTD1``. It can be set to + ``zstandard.FORMAT_ZSTD1_MAGICLESS`` to allow decoding frames without + the 4 byte magic header. Not all decompression APIs support this mode. + """ + + 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): + """Size of decompression context, in bytes. + + >>> dctx = zstandard.ZstdDecompressor() + >>> size = dctx.memory_size() + """ + return lib.ZSTD_sizeof_DCtx(self._dctx) + + def decompress( + self, + data, + max_output_size=0, + read_across_frames=False, + allow_extra_data=True, + ): + """ + Decompress data in a single operation. + + This method will decompress the input data in a single operation and + return the decompressed data. + + The input bytes are expected to contain at least 1 full Zstandard frame + (something compressed with :py:meth:`ZstdCompressor.compress` or + similar). If the input does not contain a full frame, an exception will + be raised. + + ``read_across_frames`` controls whether to read multiple zstandard + frames in the input. When False, decompression stops after reading the + first frame. This feature is not yet implemented but the argument is + provided for forward API compatibility when the default is changed to + True in a future release. For now, if you need to decompress multiple + frames, use an API like :py:meth:`ZstdCompressor.stream_reader` with + ``read_across_frames=True``. + + ``allow_extra_data`` controls how to handle extra input data after a + fully decoded frame. If False, any extra data (which could be a valid + zstd frame) will result in ``ZstdError`` being raised. If True, extra + data is silently ignored. The default will likely change to False in a + future release when ``read_across_frames`` defaults to True. + + If the input contains extra data after a full frame, that extra input + data is silently ignored. This behavior is undesirable in many scenarios + and will likely be changed or controllable in a future release (see + #181). + + If the frame header of the compressed data does not contain the content + size, ``max_output_size`` must be specified or ``ZstdError`` will be + raised. An allocation of size ``max_output_size`` will be performed and an + attempt will be made to perform decompression into that buffer. If the + buffer is too small or cannot be allocated, ``ZstdError`` will be + raised. The buffer will be resized if it is too large. + + Uncompressed data could be much larger than compressed data. As a result, + calling this function could result in a very large memory allocation + being performed to hold the uncompressed data. This could potentially + result in ``MemoryError`` or system memory swapping. If you don't need + the full output data in a single contiguous array in memory, consider + using streaming decompression for more resilient memory behavior. + + Usage: + + >>> dctx = zstandard.ZstdDecompressor() + >>> decompressed = dctx.decompress(data) + + If the compressed data doesn't have its content size embedded within it, + decompression can be attempted by specifying the ``max_output_size`` + argument: + + >>> dctx = zstandard.ZstdDecompressor() + >>> uncompressed = dctx.decompress(data, max_output_size=1048576) + + Ideally, ``max_output_size`` will be identical to the decompressed + output size. + + .. important:: + + If the exact size of decompressed data is unknown (not passed in + explicitly and not stored in the zstd frame), for performance + reasons it is encouraged to use a streaming API. + + :param data: + Compressed data to decompress. + :param max_output_size: + Integer max size of response. + + If ``0``, there is no limit and we can attempt to allocate an output + buffer of infinite size. + :return: + ``bytes`` representing decompressed output. + """ + + if read_across_frames: + raise ZstdError( + "ZstdDecompressor.read_across_frames=True is not yet implemented" + ) + + self._ensure_dctx() + + data_buffer = ffi.from_buffer(data) + + params = ffi.new("ZSTD_FrameHeader *") + zresult = lib.ZSTD_getFrameHeader_advanced( + params, data_buffer, len(data_buffer), self._format + ) + if zresult != 0: + raise ZstdError("error determining content size from frame header") + output_size = params.frameContentSize + if output_size == 0: + return b"" + elif output_size == lib.ZSTD_CONTENTSIZE_UNKNOWN: + if not max_output_size: + raise ZstdError( + "could not determine content size in frame header" + ) + + result_buffer = ffi.new("char[]", max_output_size) + result_size = max_output_size + output_size = 0 + else: + result_buffer = ffi.new("char[]", output_size) + result_size = output_size + + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = result_buffer + out_buffer.size = result_size + out_buffer.pos = 0 + + in_buffer = ffi.new("ZSTD_inBuffer *") + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer) + if lib.ZSTD_isError(zresult): + raise ZstdError("decompression error: %s" % _zstd_error(zresult)) + elif zresult: + raise ZstdError( + "decompression error: did not decompress full frame" + ) + elif output_size and out_buffer.pos != output_size: + raise ZstdError( + "decompression error: decompressed %d bytes; expected %d" + % (zresult, output_size) + ) + elif not allow_extra_data and in_buffer.pos < in_buffer.size: + count = in_buffer.size - in_buffer.pos + + raise ZstdError( + "compressed input contains %d bytes of unused data, which is disallowed" + % count + ) + + return ffi.buffer(result_buffer, out_buffer.pos)[:] + + def stream_reader( + self, + source, + read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE, + read_across_frames=False, + closefd=True, + ): + """ + Read-only stream wrapper that performs decompression. + + This method obtains an object that conforms to the ``io.RawIOBase`` + interface and performs transparent decompression via ``read()`` + operations. Source data is obtained by calling ``read()`` on a + source stream or object implementing the buffer protocol. + + See :py:class:`zstandard.ZstdDecompressionReader` for more documentation + and usage examples. + + :param source: + Source of compressed data to decompress. Can be any object + with a ``read(size)`` method or that conforms to the buffer protocol. + :param read_size: + Integer number of bytes to read from the source and feed into the + compressor at a time. + :param read_across_frames: + Whether to read data across multiple zstd frames. If False, + decompression is stopped at frame boundaries. + :param closefd: + Whether to close the source stream when this instance is closed. + :return: + :py:class:`zstandard.ZstdDecompressionReader`. + """ + self._ensure_dctx() + return ZstdDecompressionReader( + self, source, read_size, read_across_frames, closefd=closefd + ) + + def decompressobj( + self, + write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE, + read_across_frames=False, + ): + """Obtain a standard library compatible incremental decompressor. + + See :py:class:`ZstdDecompressionObj` for more documentation + and usage examples. + + :param write_size: size of internal output buffer to collect decompressed + chunks in. + :param read_across_frames: whether to read across multiple zstd frames. + If False, reading stops after 1 frame and subsequent decompress + attempts will raise an exception. + :return: + :py:class:`zstandard.ZstdDecompressionObj` + """ + if write_size < 1: + raise ValueError("write_size must be positive") + + self._ensure_dctx() + return ZstdDecompressionObj( + self, write_size=write_size, read_across_frames=read_across_frames + ) + + def read_to_iter( + self, + reader, + read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE, + write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE, + skip_bytes=0, + ): + """Read compressed data to an iterator of uncompressed chunks. + + This method will read data from ``reader``, feed it to a decompressor, + and emit ``bytes`` chunks representing the decompressed result. + + >>> dctx = zstandard.ZstdDecompressor() + >>> for chunk in dctx.read_to_iter(fh): + ... # Do something with original data. + + ``read_to_iter()`` accepts an object with a ``read(size)`` method that + will return compressed bytes or an object conforming to the buffer + protocol. + + ``read_to_iter()`` returns an iterator whose elements are chunks of the + decompressed data. + + The size of requested ``read()`` from the source can be specified: + + >>> dctx = zstandard.ZstdDecompressor() + >>> for chunk in dctx.read_to_iter(fh, read_size=16384): + ... pass + + It is also possible to skip leading bytes in the input data: + + >>> dctx = zstandard.ZstdDecompressor() + >>> for chunk in dctx.read_to_iter(fh, skip_bytes=1): + ... pass + + .. tip:: + + Skipping leading bytes is useful if the source data contains extra + *header* data. Traditionally, you would need to create a slice or + ``memoryview`` of the data you want to decompress. This would create + overhead. It is more efficient to pass the offset into this API. + + Similarly to :py:meth:`ZstdCompressor.read_to_iter`, the consumer of the + iterator controls when data is decompressed. If the iterator isn't consumed, + decompression is put on hold. + + When ``read_to_iter()`` is passed an object conforming to the buffer protocol, + the behavior may seem similar to what occurs when the simple decompression + API is used. However, this API works when the decompressed size is unknown. + Furthermore, if feeding large inputs, the decompressor will work in chunks + instead of performing a single operation. + + :param reader: + Source of compressed data. Can be any object with a + ``read(size)`` method or any object conforming to the buffer + protocol. + :param read_size: + Integer size of data chunks to read from ``reader`` and feed into + the decompressor. + :param write_size: + Integer size of data chunks to emit from iterator. + :param skip_bytes: + Integer number of bytes to skip over before sending data into + the decompressor. + :return: + Iterator of ``bytes`` representing uncompressed data. + """ + + if skip_bytes >= read_size: + raise ValueError("skip_bytes must be smaller than read_size") + + if hasattr(reader, "read"): + have_read = True + elif hasattr(reader, "__getitem__"): + have_read = False + buffer_offset = 0 + size = len(reader) + else: + raise ValueError( + "must pass an object with a read() method or " + "conforms to buffer protocol" + ) + + if skip_bytes: + if have_read: + reader.read(skip_bytes) + else: + if skip_bytes > size: + raise ValueError("skip_bytes larger than first input chunk") + + buffer_offset = skip_bytes + + self._ensure_dctx() + + in_buffer = ffi.new("ZSTD_inBuffer *") + out_buffer = ffi.new("ZSTD_outBuffer *") + + dst_buffer = ffi.new("char[]", write_size) + out_buffer.dst = dst_buffer + out_buffer.size = len(dst_buffer) + out_buffer.pos = 0 + + while True: + assert out_buffer.pos == 0 + + if have_read: + read_result = reader.read(read_size) + else: + remaining = size - buffer_offset + slice_size = min(remaining, read_size) + read_result = reader[buffer_offset : buffer_offset + slice_size] + buffer_offset += slice_size + + # No new input. Break out of read loop. + if not read_result: + break + + # Feed all read data into decompressor and emit output until + # exhausted. + read_buffer = ffi.from_buffer(read_result) + in_buffer.src = read_buffer + in_buffer.size = len(read_buffer) + in_buffer.pos = 0 + + while in_buffer.pos < in_buffer.size: + assert out_buffer.pos == 0 + + zresult = lib.ZSTD_decompressStream( + self._dctx, out_buffer, in_buffer + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd decompress error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + data = ffi.buffer(out_buffer.dst, out_buffer.pos)[:] + out_buffer.pos = 0 + yield data + + if zresult == 0: + return + + # Repeat loop to collect more input data. + continue + + # If we get here, input is exhausted. + + def stream_writer( + self, + writer, + write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE, + write_return_read=True, + closefd=True, + ): + """ + Push-based stream wrapper that performs decompression. + + This method constructs a stream wrapper that conforms to the + ``io.RawIOBase`` interface and performs transparent decompression + when writing to a wrapper stream. + + See :py:class:`zstandard.ZstdDecompressionWriter` for more documentation + and usage examples. + + :param writer: + Destination for decompressed output. Can be any object with a + ``write(data)``. + :param write_size: + Integer size of chunks to ``write()`` to ``writer``. + :param write_return_read: + Whether ``write()`` should return the number of bytes of input + consumed. If False, ``write()`` returns the number of bytes sent + to the inner stream. + :param closefd: + Whether to ``close()`` the inner stream when this stream is closed. + :return: + :py:class:`zstandard.ZstdDecompressionWriter` + """ + if not hasattr(writer, "write"): + raise ValueError("must pass an object with a write() method") + + return ZstdDecompressionWriter( + self, + writer, + write_size, + write_return_read, + closefd=closefd, + ) + + def copy_stream( + self, + ifh, + ofh, + read_size=DECOMPRESSION_RECOMMENDED_INPUT_SIZE, + write_size=DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE, + ): + """ + Copy data between streams, decompressing in the process. + + Compressed data will be read from ``ifh``, decompressed, and written + to ``ofh``. + + >>> dctx = zstandard.ZstdDecompressor() + >>> dctx.copy_stream(ifh, ofh) + + e.g. to decompress a file to another file: + + >>> dctx = zstandard.ZstdDecompressor() + >>> with open(input_path, 'rb') as ifh, open(output_path, 'wb') as ofh: + ... dctx.copy_stream(ifh, ofh) + + The size of chunks being ``read()`` and ``write()`` from and to the + streams can be specified: + + >>> dctx = zstandard.ZstdDecompressor() + >>> dctx.copy_stream(ifh, ofh, read_size=8192, write_size=16384) + + :param ifh: + Source stream to read compressed data from. + + Must have a ``read()`` method. + :param ofh: + Destination stream to write uncompressed data to. + + Must have a ``write()`` method. + :param read_size: + The number of bytes to ``read()`` from the source in a single + operation. + :param write_size: + The number of bytes to ``write()`` to the destination in a single + operation. + :return: + 2-tuple of integers representing the number of bytes read and + written, respectively. + """ + + if not hasattr(ifh, "read"): + raise ValueError("first argument must have a read() method") + if not hasattr(ofh, "write"): + raise ValueError("second argument must have a write() method") + + self._ensure_dctx() + + in_buffer = ffi.new("ZSTD_inBuffer *") + out_buffer = ffi.new("ZSTD_outBuffer *") + + dst_buffer = ffi.new("char[]", write_size) + out_buffer.dst = dst_buffer + out_buffer.size = write_size + out_buffer.pos = 0 + + total_read, total_write = 0, 0 + + # Read all available input. + while True: + data = ifh.read(read_size) + if not data: + break + + data_buffer = ffi.from_buffer(data) + total_read += len(data_buffer) + in_buffer.src = data_buffer + in_buffer.size = len(data_buffer) + in_buffer.pos = 0 + + # Flush all read data to output. + while in_buffer.pos < in_buffer.size: + zresult = lib.ZSTD_decompressStream( + self._dctx, out_buffer, in_buffer + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "zstd decompressor error: %s" % _zstd_error(zresult) + ) + + if out_buffer.pos: + ofh.write(ffi.buffer(out_buffer.dst, out_buffer.pos)) + total_write += out_buffer.pos + out_buffer.pos = 0 + + # Continue loop to keep reading. + + return total_read, total_write + + def decompress_content_dict_chain(self, frames): + """ + Decompress a series of frames using the content dictionary chaining technique. + + Such a list of frames is produced by compressing discrete inputs where + each non-initial input is compressed with a *prefix* dictionary consisting + of the content of the previous input. + + For example, say you have the following inputs: + + >>> inputs = [b"input 1", b"input 2", b"input 3"] + + The zstd frame chain consists of: + + 1. ``b"input 1"`` compressed in standalone/discrete mode + 2. ``b"input 2"`` compressed using ``b"input 1"`` as a *prefix* dictionary + 3. ``b"input 3"`` compressed using ``b"input 2"`` as a *prefix* dictionary + + Each zstd frame **must** have the content size written. + + The following Python code can be used to produce a *prefix dictionary chain*: + + >>> def make_chain(inputs): + ... frames = [] + ... + ... # First frame is compressed in standalone/discrete mode. + ... zctx = zstandard.ZstdCompressor() + ... frames.append(zctx.compress(inputs[0])) + ... + ... # Subsequent frames use the previous fulltext as a prefix dictionary + ... for i, raw in enumerate(inputs[1:]): + ... dict_data = zstandard.ZstdCompressionDict( + ... inputs[i], dict_type=zstandard.DICT_TYPE_RAWCONTENT) + ... zctx = zstandard.ZstdCompressor(dict_data=dict_data) + ... frames.append(zctx.compress(raw)) + ... + ... return frames + + ``decompress_content_dict_chain()`` returns the uncompressed data of the last + element in the input chain. + + .. note:: + + It is possible to implement *prefix dictionary chain* decompression + on top of other APIs. However, this function will likely be faster - + especially for long input chains - as it avoids the overhead of + instantiating and passing around intermediate objects between + multiple functions. + + :param frames: + List of ``bytes`` holding compressed zstd frames. + :return: + """ + 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): + raise ValueError("chunk 0 must be bytes") + + # All chunks should be zstd frames and should have content size set. + chunk_buffer = ffi.from_buffer(chunk) + params = ffi.new("ZSTD_FrameHeader *") + zresult = lib.ZSTD_getFrameHeader( + params, chunk_buffer, len(chunk_buffer) + ) + if lib.ZSTD_isError(zresult): + raise ValueError("chunk 0 is not a valid zstd frame") + elif zresult: + raise ValueError("chunk 0 is too small to contain a zstd frame") + + if params.frameContentSize == lib.ZSTD_CONTENTSIZE_UNKNOWN: + raise ValueError("chunk 0 missing content size in frame") + + self._ensure_dctx(load_dict=False) + + last_buffer = ffi.new("char[]", params.frameContentSize) + + out_buffer = ffi.new("ZSTD_outBuffer *") + out_buffer.dst = last_buffer + out_buffer.size = len(last_buffer) + out_buffer.pos = 0 + + in_buffer = ffi.new("ZSTD_inBuffer *") + in_buffer.src = chunk_buffer + in_buffer.size = len(chunk_buffer) + in_buffer.pos = 0 + + zresult = lib.ZSTD_decompressStream(self._dctx, out_buffer, in_buffer) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "could not decompress chunk 0: %s" % _zstd_error(zresult) + ) + elif zresult: + raise ZstdError("chunk 0 did not decompress full frame") + + # Special case of chain length of 1 + if len(frames) == 1: + return ffi.buffer(last_buffer, len(last_buffer))[:] + + i = 1 + while i < len(frames): + chunk = frames[i] + if not isinstance(chunk, bytes): + raise ValueError("chunk %d must be bytes" % i) + + chunk_buffer = ffi.from_buffer(chunk) + zresult = lib.ZSTD_getFrameHeader( + params, chunk_buffer, len(chunk_buffer) + ) + if lib.ZSTD_isError(zresult): + raise ValueError("chunk %d is not a valid zstd frame" % i) + elif zresult: + raise ValueError( + "chunk %d is too small to contain a zstd frame" % i + ) + + if params.frameContentSize == lib.ZSTD_CONTENTSIZE_UNKNOWN: + raise ValueError("chunk %d missing content size in frame" % i) + + dest_buffer = ffi.new("char[]", params.frameContentSize) + + out_buffer.dst = dest_buffer + out_buffer.size = len(dest_buffer) + out_buffer.pos = 0 + + in_buffer.src = chunk_buffer + in_buffer.size = len(chunk_buffer) + in_buffer.pos = 0 + + zresult = lib.ZSTD_decompressStream( + self._dctx, out_buffer, in_buffer + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "could not decompress chunk %d: %s" % _zstd_error(zresult) + ) + elif zresult: + raise ZstdError("chunk %d did not decompress full frame" % i) + + last_buffer = dest_buffer + i += 1 + + return ffi.buffer(last_buffer, len(last_buffer))[:] + + def multi_decompress_to_buffer( + self, frames, decompressed_sizes=None, threads=0 + ): + """ + Decompress multiple zstd frames to output buffers as a single operation. + + (Experimental. Not available in CFFI backend.) + + Compressed frames can be passed to the function as a + ``BufferWithSegments``, a ``BufferWithSegmentsCollection``, or as a + list containing objects that conform to the buffer protocol. For best + performance, pass a ``BufferWithSegmentsCollection`` or a + ``BufferWithSegments``, as minimal input validation will be done for + that type. If calling from Python (as opposed to C), constructing one + of these instances may add overhead cancelling out the performance + overhead of validation for list inputs. + + Returns a ``BufferWithSegmentsCollection`` containing the decompressed + data. All decompressed data is allocated in a single memory buffer. The + ``BufferWithSegments`` instance tracks which objects are at which offsets + and their respective lengths. + + >>> dctx = zstandard.ZstdDecompressor() + >>> results = dctx.multi_decompress_to_buffer([b'...', b'...']) + + The decompressed size of each frame MUST be discoverable. It can either be + embedded within the zstd frame or passed in via the ``decompressed_sizes`` + argument. + + The ``decompressed_sizes`` argument is an object conforming to the buffer + protocol which holds an array of 64-bit unsigned integers in the machine's + native format defining the decompressed sizes of each frame. If this argument + is passed, it avoids having to scan each frame for its decompressed size. + This frame scanning can add noticeable overhead in some scenarios. + + >>> frames = [...] + >>> sizes = struct.pack('=QQQQ', len0, len1, len2, len3) + >>> + >>> dctx = zstandard.ZstdDecompressor() + >>> results = dctx.multi_decompress_to_buffer(frames, decompressed_sizes=sizes) + + .. note:: + + It is possible to pass a ``mmap.mmap()`` instance into this function by + wrapping it with a ``BufferWithSegments`` instance (which will define the + offsets of frames within the memory mapped region). + + This function is logically equivalent to performing + :py:meth:`ZstdCompressor.decompress` on each input frame and returning the + result. + + This function exists to perform decompression on multiple frames as fast + as possible by having as little overhead as possible. Since decompression is + performed as a single operation and since the decompressed output is stored in + a single buffer, extra memory allocations, Python objects, and Python function + calls are avoided. This is ideal for scenarios where callers know up front that + they need to access data for multiple frames, such as when *delta chains* are + being used. + + Currently, the implementation always spawns multiple threads when requested, + even if the amount of work to do is small. In the future, it will be smarter + about avoiding threads and their associated overhead when the amount of + work to do is small. + + :param frames: + Source defining zstd frames to decompress. + :param decompressed_sizes: + Array of integers representing sizes of decompressed zstd frames. + :param threads: + How many threads to use for decompression operations. + + Negative values will use the same number of threads as logical CPUs + on the machine. Values ``0`` or ``1`` use a single thread. + :return: + ``BufferWithSegmentsCollection`` + """ + raise NotImplementedError() + + def _ensure_dctx(self, load_dict=True): + lib.ZSTD_DCtx_reset(self._dctx, lib.ZSTD_reset_session_only) + + if self._max_window_size: + zresult = lib.ZSTD_DCtx_setMaxWindowSize( + self._dctx, self._max_window_size + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "unable to set max window size: %s" % _zstd_error(zresult) + ) + + zresult = lib.ZSTD_DCtx_setParameter( + self._dctx, lib.ZSTD_d_format, self._format + ) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "unable to set decoding format: %s" % _zstd_error(zresult) + ) + + if self._dict_data and load_dict: + zresult = lib.ZSTD_DCtx_refDDict(self._dctx, self._dict_data._ddict) + if lib.ZSTD_isError(zresult): + raise ZstdError( + "unable to reference prepared dictionary: %s" + % _zstd_error(zresult) + ) diff --git a/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/py.typed b/apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/apps/desktop/electron/codex-link-config.ts b/apps/desktop/electron/codex-link-config.ts index ec6efcf..53ae738 100644 --- a/apps/desktop/electron/codex-link-config.ts +++ b/apps/desktop/electron/codex-link-config.ts @@ -21,12 +21,13 @@ export const CODEX_LINK_PORT = 8795 export const CODEX_LINK_ORIGIN = `http://127.0.0.1:${CODEX_LINK_PORT}` export const CODEX_LINK_STATUS_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/status` export const CODEX_LINK_STOP_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/stop` +export const CODEX_LINK_REFRESH_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/refresh` /** The trailing comment that marks the line as ours. */ export const CODEX_LINK_MARKER = '# AITURK IDE Codex Baglama' // Must equal SURUM in assets/codex-bridge/bridge.py; a running bridge that reports // another version is restarted so an updated IDE never keeps an old bridge alive. -export const CODEX_BRIDGE_VERSION = '1' +export const CODEX_BRIDGE_VERSION = '2' export const CODEX_LINK_LINE = `openai_base_url = "${CODEX_LINK_ORIGIN}/backend-api/codex" ${CODEX_LINK_MARKER}` export const CODEX_LINK_BACKUP_SUFFIX = '.aiturk-yedek' diff --git a/apps/desktop/electron/codex-link.test.ts b/apps/desktop/electron/codex-link.test.ts index 35f6ddf..f757559 100644 --- a/apps/desktop/electron/codex-link.test.ts +++ b/apps/desktop/electron/codex-link.test.ts @@ -3,6 +3,7 @@ import { describe, expect, it } from 'vitest' import { CODEX_BRIDGE_START_BUDGET_MS, type CodexLinkDeps, type CodexLinkPaths, createCodexLink } from './codex-link' import { CODEX_LINK_LINE, + CODEX_LINK_REFRESH_URL, CODEX_LINK_STATUS_URL, CODEX_LINK_STOP_URL, codexBridgeArgs, @@ -21,7 +22,7 @@ const PATHS: CodexLinkPaths = { const BRIDGE_JSON = `${PATHS.bridgeHome}\\bridge.json` const BACKUP = `${PATHS.codexConfig}.aiturk-yedek` -const STATUS_OK = { ok: true, surum: '1', ide_durum: 'tamam', ide_model: 7, ozet: true } +const STATUS_OK = { ok: true, surum: '2', ide_durum: 'tamam', ide_model: 7, ozet: true } const USER_CONFIG = 'model = "gpt-6"\r\n\r\n[features]\r\nweb = true\r\n' interface World { @@ -103,6 +104,12 @@ function createWorld(patch: Partial & { files?: Map } = { return null } + if (method === 'POST' && url === CODEX_LINK_REFRESH_URL) { + world.events.push('refresh') + + return world.listening ? STATUS_OK : null + } + if (method === 'POST' && url === CODEX_LINK_STOP_URL) { world.events.push('stop') @@ -273,6 +280,15 @@ describe('applyCodexLink', () => { expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`) }) + it('asks a running bridge to re-read the IDE session on every apply', async () => { + const { link, world } = createWorld({ listening: true }) + + await link.apply({ sync: true }) + + expect(world.events).toContain('refresh') + expect(spawns(world)).toEqual([]) + }) + it('never overwrites the first backup', async () => { const { link, world } = createWorld({ listening: true }) world.files.set(BACKUP, 'the original original') diff --git a/apps/desktop/electron/codex-link.ts b/apps/desktop/electron/codex-link.ts index 632017d..a8081f4 100644 --- a/apps/desktop/electron/codex-link.ts +++ b/apps/desktop/electron/codex-link.ts @@ -25,6 +25,7 @@ import { CODEX_BRIDGE_VERSION, CODEX_LINK_BACKUP_SUFFIX, CODEX_LINK_LAUNCHER_NAME, + CODEX_LINK_REFRESH_URL, CODEX_LINK_RUN_KEY, CODEX_LINK_RUN_VALUE, CODEX_LINK_STATUS_URL, @@ -306,7 +307,17 @@ export function createCodexLink(deps: CodexLinkDeps): CodexLink { bridge = NOT_RUNNING } - if (!bridge.running) { + if (bridge.running) { + // Already up: have it re-read the IDE session and model list now (a sign-in + // since its last periodic refresh would otherwise show up minutes later). + try { + const refreshed = readProbe(await deps.request('POST', CODEX_LINK_REFRESH_URL, CODEX_BRIDGE_START_BUDGET_MS)) + + bridge = refreshed.running ? refreshed : bridge + } catch { + // The status it already gave stays valid. + } + } else { bridge = await startBridge(python) } diff --git a/apps/desktop/package.json b/apps/desktop/package.json index 159e1d0..10b885d 100644 --- a/apps/desktop/package.json +++ b/apps/desktop/package.json @@ -304,7 +304,9 @@ "from": "assets/codex-bridge", "to": "codex-bridge", "filter": [ - "*.py", + "**/*.py", + "**/*.pyd", + "**/LICENSE", "!test_*.py" ] }