commit ca85a528390036f9bbe1a2c1de0c5437b37e9eb0 Author: senstella Date: Sat Jan 17 14:13:43 2026 +0900 init diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..505a3b1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +# Python-generated files +__pycache__/ +*.py[oc] +build/ +dist/ +wheels/ +*.egg-info + +# Virtual environments +.venv diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/README.md b/README.md new file mode 100644 index 0000000..0fc37bc --- /dev/null +++ b/README.md @@ -0,0 +1,71 @@ +# py-pwr + +Minimal Python client for wharf/pwr files. It parses the wire format, +protobuf messages, and can apply patch ops when you provide file index +to path mappings. + +## Features +- Read `.pwr`, `.pws`, `.pwm`, `.pww` files. +- Iterate sync ops and bsdiff controls. +- Apply patches for RSYNC and BSDIFF series using target/output file lists. +- Optional decompression for brotli/zstd if the modules are installed. + +## Limitations +- TLC container decoding is not included. You can pass a decoder to + `PatchReader`/`SignatureReader` to parse the raw container bytes. + +## Usage + +Patch inspection: + +```python +from pwr import PatchReader + +with PatchReader.open("update.pwr") as reader: + for entry in reader.iter_file_entries(): + if entry.is_rsync(): + for op in entry.sync_ops: + pass + elif entry.is_bsdiff(): + for ctrl in entry.bsdiff_controls: + pass +``` + +Apply a patch (requires file index mappings): + +```python +from pwr import PatchReader, apply_patch + +target_paths = [ + "old/file0.bin", + "old/file1.bin", +] + +output_paths = [ + "new/file0.bin", + "new/file1.bin", +] + +with PatchReader.open("update.pwr") as reader: + apply_patch(reader, target_paths, output_paths) +``` + +Apply to folders (uses embedded TLC container paths): + +```python +from pwr import apply_patch_to_folders + +apply_patch_to_folders("update.pwr", "old_folder", "new_folder") +``` + +Quick inspect: + +```bash +python py-pwr/main.py path/to/file.pwr +``` + +Apply via CLI: + +```bash +python py-pwr/main.py apply update.pwr /path/to/old_folder /path/to/new_folder +``` diff --git a/main.py b/main.py new file mode 100644 index 0000000..0c5f4dc --- /dev/null +++ b/main.py @@ -0,0 +1,131 @@ +import argparse +import sys + +from pwr import ( + MANIFEST_MAGIC, + PATCH_MAGIC, + SIGNATURE_MAGIC, + WOUNDS_MAGIC, + ManifestReader, + PatchReader, + SignatureReader, + SyncOpType, + WoundsReader, + apply_patch_to_folders, +) +from pwr.wire import read_magic + + +def _inspect_patch(path: str) -> None: + files = 0 + rsync_files = 0 + bsdiff_files = 0 + ops = 0 + data_bytes = 0 + controls = 0 + + with PatchReader.open(path) as reader: + compression = reader.header.compression.algorithm if reader.header and reader.header.compression else None + for entry in reader.iter_file_entries(): + files += 1 + if entry.is_rsync(): + rsync_files += 1 + for op in entry.sync_ops or []: + ops += 1 + if op.type == SyncOpType.DATA: + data_bytes += len(op.data or b"") + elif entry.is_bsdiff(): + bsdiff_files += 1 + for ctrl in entry.bsdiff_controls or []: + controls += 1 + data_bytes += len(ctrl.add or b"") + len(ctrl.copy or b"") + + print("patch") + print(f" files: {files} (rsync={rsync_files}, bsdiff={bsdiff_files})") + print(f" ops: {ops}, controls: {controls}") + print(f" data bytes: {data_bytes}") + print(f" compression: {compression}") + + +def _inspect_signature(path: str) -> None: + blocks = 0 + with SignatureReader.open(path) as reader: + compression = reader.header.compression.algorithm if reader.header and reader.header.compression else None + for _ in reader.iter_block_hashes(): + blocks += 1 + print("signature") + print(f" block hashes: {blocks}") + print(f" compression: {compression}") + + +def _inspect_manifest(path: str) -> None: + hashes = 0 + with ManifestReader.open(path) as reader: + compression = reader.header.compression.algorithm if reader.header and reader.header.compression else None + for _ in reader.iter_block_hashes(): + hashes += 1 + print("manifest") + print(f" block hashes: {hashes}") + print(f" compression: {compression}") + + +def _inspect_wounds(path: str) -> None: + wounds = 0 + with WoundsReader.open(path) as reader: + for _ in reader.iter_wounds(): + wounds += 1 + print("wounds") + print(f" wounds: {wounds}") + + +def main() -> None: + parser = argparse.ArgumentParser(description="Minimal wharf/pwr inspector") + subparsers = parser.add_subparsers(dest="command") + + inspect_parser = subparsers.add_parser("inspect", help="inspect a wharf file") + inspect_parser.add_argument("path", help="path to .pwr/.pws/.pwm/.pww file") + + apply_parser = subparsers.add_parser("apply", help="apply a .pwr patch to folders") + apply_parser.add_argument("patch", help="path to .pwr file") + apply_parser.add_argument("target", help="folder with the old version") + apply_parser.add_argument("output", help="folder to write the new version") + + parser.add_argument( + "path", + nargs="?", + help="path to .pwr/.pws/.pwm/.pww file (shorthand for inspect)", + ) + + args = parser.parse_args() + + if args.command == "apply": + apply_patch_to_folders(args.patch, args.target, args.output) + return + + path = None + if args.command == "inspect": + path = args.path + elif args.path: + path = args.path + + if not path: + parser.print_help(sys.stderr) + return + + with open(path, "rb") as handle: + magic = read_magic(handle) + + if magic == PATCH_MAGIC: + _inspect_patch(path) + elif magic == SIGNATURE_MAGIC: + _inspect_signature(path) + elif magic == MANIFEST_MAGIC: + _inspect_manifest(path) + elif magic == WOUNDS_MAGIC: + _inspect_wounds(path) + else: + print(f"unknown magic: {magic}") + + +if __name__ == "__main__": + main() diff --git a/pwr/__init__.py b/pwr/__init__.py new file mode 100644 index 0000000..b2f30ea --- /dev/null +++ b/pwr/__init__.py @@ -0,0 +1,97 @@ +from .apply import ( + FilePool, + PatchApplyError, + apply_bsdiff_controls, + apply_patch, + apply_patch_to_folders, + apply_rsync_ops, +) +from .compression import CompressionError +from .formats import FilePatch, ManifestReader, PatchReader, SignatureReader, WoundsReader +from .proto import ( + BlockHash, + BsdiffHeader, + CompressionAlgorithm, + CompressionSettings, + Control, + HashAlgorithm, + ManifestBlockHash, + ManifestHeader, + OverlayHeader, + OverlayOp, + OverlayOpType, + PatchHeader, + Sample, + SignatureHeader, + SyncHeader, + SyncHeaderType, + SyncOp, + SyncOpType, + TlcContainer, + TlcDir, + TlcFile, + TlcSymlink, + Wound, + WoundKind, + WoundsHeader, +) +from .wire import ( + BLOCK_SIZE, + MANIFEST_MAGIC, + PATCH_MAGIC, + SIGNATURE_MAGIC, + WOUNDS_MAGIC, + ZIP_INDEX_MAGIC, + WireError, + WireReader, + WireWriter, +) + +__all__ = [ + "FilePool", + "PatchApplyError", + "apply_bsdiff_controls", + "apply_patch", + "apply_patch_to_folders", + "apply_rsync_ops", + "CompressionError", + "FilePatch", + "ManifestReader", + "PatchReader", + "SignatureReader", + "WoundsReader", + "BlockHash", + "BsdiffHeader", + "CompressionAlgorithm", + "CompressionSettings", + "Control", + "HashAlgorithm", + "ManifestBlockHash", + "ManifestHeader", + "OverlayHeader", + "OverlayOp", + "OverlayOpType", + "PatchHeader", + "Sample", + "SignatureHeader", + "SyncHeader", + "SyncHeaderType", + "SyncOp", + "SyncOpType", + "TlcContainer", + "TlcDir", + "TlcFile", + "TlcSymlink", + "Wound", + "WoundKind", + "WoundsHeader", + "BLOCK_SIZE", + "MANIFEST_MAGIC", + "PATCH_MAGIC", + "SIGNATURE_MAGIC", + "WOUNDS_MAGIC", + "ZIP_INDEX_MAGIC", + "WireError", + "WireReader", + "WireWriter", +] diff --git a/pwr/apply.py b/pwr/apply.py new file mode 100644 index 0000000..b6ed285 --- /dev/null +++ b/pwr/apply.py @@ -0,0 +1,198 @@ +from __future__ import annotations + +import os +from typing import BinaryIO + +from .formats import FilePatch, PatchReader +from .proto import Control, SyncOp, SyncOpType +from .proto import TlcContainer, TlcDir, TlcFile, TlcSymlink +from .wire import BLOCK_SIZE + + +class PatchApplyError(Exception): + pass + + +_MODE_MASK = 0o7777 + + +class FilePool: + def __init__(self, paths: list[str]): + self._paths = list(paths) + self._handles: dict[int, BinaryIO] = {} + + def open(self, index: int) -> BinaryIO: + if index < 0 or index >= len(self._paths): + raise PatchApplyError(f"file index out of range: {index}") + handle = self._handles.get(index) + if handle is None: + handle = open(self._paths[index], "rb") + self._handles[index] = handle + return handle + + def size(self, index: int) -> int: + if index < 0 or index >= len(self._paths): + raise PatchApplyError(f"file index out of range: {index}") + return os.path.getsize(self._paths[index]) + + def close(self) -> None: + for handle in self._handles.values(): + handle.close() + self._handles.clear() + + +def _copy_range(dst: BinaryIO, src: BinaryIO, length: int, buffer_size: int = 32 * 1024) -> None: + remaining = length + while remaining > 0: + chunk = src.read(min(buffer_size, remaining)) + if not chunk: + raise PatchApplyError("unexpected EOF while copying block range") + dst.write(chunk) + remaining -= len(chunk) + + +def apply_rsync_ops(ops: list[SyncOp], target_pool: FilePool, output: BinaryIO) -> None: + for op in ops: + if op.type == SyncOpType.DATA: + output.write(op.data or b"") + continue + + if op.type != SyncOpType.BLOCK_RANGE: + raise PatchApplyError(f"unsupported sync op type: {op.type}") + + if op.file_index is None or op.block_index is None or op.block_span is None: + raise PatchApplyError("missing fields in block range op") + if op.block_span <= 0: + raise PatchApplyError("invalid block span in block range op") + + file_size = target_pool.size(op.file_index) + last_block_index = op.block_index + op.block_span - 1 + last_block_size = BLOCK_SIZE + if BLOCK_SIZE * (last_block_index + 1) > file_size: + last_block_size = file_size % BLOCK_SIZE + op_size = (op.block_span - 1) * BLOCK_SIZE + last_block_size + + src = target_pool.open(op.file_index) + src.seek(op.block_index * BLOCK_SIZE) + _copy_range(output, src, op_size) + + +def apply_bsdiff_controls(controls: list[Control], old: BinaryIO, output: BinaryIO) -> None: + old_offset = 0 + for ctrl in controls: + if ctrl.eof: + break + + add = ctrl.add or b"" + copy = ctrl.copy or b"" + seek = ctrl.seek or 0 + + if add: + old.seek(old_offset) + old_chunk = old.read(len(add)) + if len(old_chunk) != len(add): + raise PatchApplyError("unexpected EOF while reading bsdiff add data") + out = bytes(((a + b) & 0xFF) for a, b in zip(old_chunk, add)) + output.write(out) + old_offset += len(add) + + if copy: + output.write(copy) + + old_offset += seek + + +def _ensure_parent(path: str) -> None: + parent = os.path.dirname(path) + if parent: + os.makedirs(parent, exist_ok=True) + + +def apply_patch(patch_reader: PatchReader, target_paths: list[str], output_paths: list[str]) -> None: + pool = FilePool(target_paths) + try: + for entry in patch_reader.iter_file_entries(): + if entry.sync_header.file_index is None: + raise PatchApplyError("missing file_index in sync header") + out_index = entry.sync_header.file_index + if out_index < 0 or out_index >= len(output_paths): + raise PatchApplyError(f"output index out of range: {out_index}") + + out_path = output_paths[out_index] + _ensure_parent(out_path) + + with open(out_path, "wb") as out: + if entry.is_rsync(): + if entry.sync_ops is None: + raise PatchApplyError("missing rsync ops") + apply_rsync_ops(entry.sync_ops, pool, out) + elif entry.is_bsdiff(): + if entry.bsdiff_header is None or entry.bsdiff_controls is None: + raise PatchApplyError("missing bsdiff data") + if entry.bsdiff_header.target_index is None: + raise PatchApplyError("missing target_index in bsdiff header") + old = pool.open(entry.bsdiff_header.target_index) + apply_bsdiff_controls(entry.bsdiff_controls, old, out) + else: + raise PatchApplyError("unknown file patch type") + finally: + pool.close() + + +def _container_file_paths(container: TlcContainer, root: str) -> list[str]: + paths = [] + for f in container.files: + if f.path is None: + raise PatchApplyError("container file missing path") + paths.append(os.path.join(root, f.path)) + return paths + + +def _ensure_dirs(container: TlcContainer, root: str) -> None: + for d in container.dirs: + if d.path is None: + continue + path = os.path.join(root, d.path) + os.makedirs(path, exist_ok=True) + if d.mode is not None: + mode = int(d.mode) & _MODE_MASK + try: + os.chmod(path, mode) + except (PermissionError, OSError): + pass + + +def _ensure_symlinks(container: TlcContainer, root: str) -> None: + for s in container.symlinks: + if s.path is None or s.dest is None: + continue + path = os.path.join(root, s.path) + if os.path.lexists(path): + continue + parent = os.path.dirname(path) + if parent: + os.makedirs(parent, exist_ok=True) + try: + os.symlink(s.dest, path) + except (AttributeError, OSError): + continue + + +def apply_patch_to_folders(patch_path: str, target_root: str, output_root: str) -> None: + with PatchReader.open( + patch_path, + container_decoder=(TlcContainer.from_bytes, TlcContainer.from_bytes), + ) as reader: + if reader.target_container is None or reader.source_container is None: + raise PatchApplyError("missing containers in patch") + + target_container: TlcContainer = reader.target_container + source_container: TlcContainer = reader.source_container + + _ensure_dirs(source_container, output_root) + _ensure_symlinks(source_container, output_root) + + target_paths = _container_file_paths(target_container, target_root) + output_paths = _container_file_paths(source_container, output_root) + + apply_patch(reader, target_paths, output_paths) diff --git a/pwr/compression.py b/pwr/compression.py new file mode 100644 index 0000000..fded62b --- /dev/null +++ b/pwr/compression.py @@ -0,0 +1,158 @@ +from __future__ import annotations + +import io +import gzip +from typing import BinaryIO + +from .proto import CompressionAlgorithm, CompressionSettings + + +class CompressionError(Exception): + pass + + +def _normalize_algorithm(algorithm: CompressionAlgorithm | int | None) -> CompressionAlgorithm: + if algorithm is None: + return CompressionAlgorithm.NONE + if isinstance(algorithm, CompressionAlgorithm): + return algorithm + try: + return CompressionAlgorithm(int(algorithm)) + except ValueError as exc: + raise CompressionError(f"unknown compression algorithm: {algorithm}") from exc + + +def _brotli_module(): + try: + import brotli # type: ignore + + return brotli + except ImportError: + try: + import brotlicffi as brotli # type: ignore + + return brotli + except ImportError as exc: + raise CompressionError("brotli module not available") from exc + + +class _BrotliReader(io.RawIOBase): + def __init__(self, raw: BinaryIO): + self._raw = raw + brotli = _brotli_module() + self._decompressor = brotli.Decompressor() + self._buffer = bytearray() + self._eof = False + + def readable(self) -> bool: + return True + + def _finish(self) -> bytes: + if hasattr(self._decompressor, "finish"): + return self._decompressor.finish() + if hasattr(self._decompressor, "flush"): + return self._decompressor.flush() + return b"" + + def read(self, size: int = -1) -> bytes: + if size == 0: + return b"" + + while not self._eof and (size < 0 or len(self._buffer) < size): + chunk = self._raw.read(8192) + if not chunk: + self._buffer.extend(self._finish()) + self._eof = True + break + self._buffer.extend(self._decompressor.process(chunk)) + + if size < 0: + data = bytes(self._buffer) + self._buffer.clear() + return data + + data = bytes(self._buffer[:size]) + del self._buffer[:size] + return data + + def readinto(self, b) -> int: + data = self.read(len(b)) + n = len(data) + b[:n] = data + return n + + def close(self) -> None: + if self.closed: + return + try: + if hasattr(self._raw, "close"): + self._raw.close() + finally: + super().close() + + +class _BrotliWriter(io.RawIOBase): + def __init__(self, raw: BinaryIO, quality: int | None): + self._raw = raw + brotli = _brotli_module() + kwargs = {} + if quality is not None: + kwargs["quality"] = int(quality) + self._compressor = brotli.Compressor(**kwargs) + + def writable(self) -> bool: + return True + + def write(self, b: bytes) -> int: + out = self._compressor.process(b) + self._raw.write(out) + return len(b) + + def close(self) -> None: + if self.closed: + return + try: + tail = self._compressor.finish() + if tail: + self._raw.write(tail) + if hasattr(self._raw, "close"): + self._raw.close() + finally: + super().close() + + +def open_decompressed_reader(stream: BinaryIO, compression: CompressionSettings | None) -> BinaryIO: + algorithm = _normalize_algorithm(compression.algorithm if compression else None) + if algorithm == CompressionAlgorithm.NONE: + return stream + if algorithm == CompressionAlgorithm.GZIP: + return gzip.GzipFile(fileobj=stream, mode="rb") + if algorithm == CompressionAlgorithm.BROTLI: + return io.BufferedReader(_BrotliReader(stream)) + if algorithm == CompressionAlgorithm.ZSTD: + try: + import zstandard as zstd # type: ignore + except ImportError as exc: + raise CompressionError("zstandard module not available") from exc + return zstd.ZstdDecompressor().stream_reader(stream) + raise CompressionError(f"unsupported compression algorithm: {algorithm}") + + +def open_compressed_writer(stream: BinaryIO, compression: CompressionSettings | None) -> BinaryIO: + algorithm = _normalize_algorithm(compression.algorithm if compression else None) + quality = compression.quality if compression else None + if algorithm == CompressionAlgorithm.NONE: + return stream + if algorithm == CompressionAlgorithm.GZIP: + level = 9 if quality is None else int(quality) + return gzip.GzipFile(fileobj=stream, mode="wb", compresslevel=level) + if algorithm == CompressionAlgorithm.BROTLI: + return io.BufferedWriter(_BrotliWriter(stream, quality)) + if algorithm == CompressionAlgorithm.ZSTD: + try: + import zstandard as zstd # type: ignore + except ImportError as exc: + raise CompressionError("zstandard module not available") from exc + level = 3 if quality is None else int(quality) + return zstd.ZstdCompressor(level=level).stream_writer(stream) + raise CompressionError(f"unsupported compression algorithm: {algorithm}") diff --git a/pwr/formats.py b/pwr/formats.py new file mode 100644 index 0000000..c6e18d0 --- /dev/null +++ b/pwr/formats.py @@ -0,0 +1,286 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Callable, Iterator + +from .compression import open_decompressed_reader +from .proto import ( + BlockHash, + BsdiffHeader, + Control, + ManifestBlockHash, + ManifestHeader, + PatchHeader, + SignatureHeader, + SyncHeader, + SyncHeaderType, + SyncOp, + SyncOpType, + Wound, + WoundsHeader, +) +from .wire import ( + MANIFEST_MAGIC, + PATCH_MAGIC, + SIGNATURE_MAGIC, + WOUNDS_MAGIC, + WireError, + WireReader, +) + +ContainerDecoder = Callable[[bytes], Any] + + +def _split_decoder(decoder: ContainerDecoder | tuple[ContainerDecoder | None, ContainerDecoder | None] | None): + if decoder is None: + return None, None + if isinstance(decoder, tuple): + if len(decoder) != 2: + raise ValueError("container decoder tuple must have two elements") + return decoder + return decoder, decoder + + +@dataclass +class FilePatch: + sync_header: SyncHeader + sync_ops: list[SyncOp] | None = None + bsdiff_header: BsdiffHeader | None = None + bsdiff_controls: list[Control] | None = None + + def is_rsync(self) -> bool: + return self.sync_ops is not None + + def is_bsdiff(self) -> bool: + return self.bsdiff_header is not None + + +class PatchReader: + def __init__(self, stream, *, container_decoder: ContainerDecoder | tuple[ContainerDecoder | None, ContainerDecoder | None] | None = None): + self._stream = stream + self._raw_wire = WireReader(stream) + self._wire: WireReader | None = None + + self.header: PatchHeader | None = None + self.target_container_raw: bytes | None = None + self.source_container_raw: bytes | None = None + self.target_container: Any | None = None + self.source_container: Any | None = None + + self._init_stream(container_decoder) + + @classmethod + def open(cls, path: str, *, container_decoder: ContainerDecoder | tuple[ContainerDecoder | None, ContainerDecoder | None] | None = None): + return cls(open(path, "rb"), container_decoder=container_decoder) + + def _init_stream(self, container_decoder): + self._raw_wire.expect_magic(PATCH_MAGIC) + self.header = self._raw_wire.read_message(PatchHeader) + + decompressed = open_decompressed_reader(self._stream, self.header.compression) + self._wire = WireReader(decompressed) + + target_decoder, source_decoder = _split_decoder(container_decoder) + self.target_container_raw, self.target_container = self._read_container(target_decoder) + self.source_container_raw, self.source_container = self._read_container(source_decoder) + + def _read_container(self, decoder: ContainerDecoder | None): + assert self._wire is not None + raw = self._wire.read_message_bytes() + parsed = decoder(raw) if decoder else None + return raw, parsed + + def iter_file_entries(self) -> Iterator[FilePatch]: + assert self._wire is not None + file_index = 0 + while True: + try: + sync_header = self._wire.read_message(SyncHeader) + except EOFError: + return + + if sync_header.file_index is None: + sync_header.file_index = file_index + else: + file_index = int(sync_header.file_index) + + header_type = sync_header.type + if header_type is None: + header_type = SyncHeaderType.RSYNC + else: + try: + header_type = SyncHeaderType(int(header_type)) + except ValueError: + raise WireError(f"unknown sync header type: {header_type}") + + if header_type == SyncHeaderType.BSDIFF: + bsdiff_header = self._wire.read_message(BsdiffHeader) + controls: list[Control] = [] + while True: + ctrl = self._wire.read_message(Control) + controls.append(ctrl) + if ctrl.eof: + break + + sentinel = self._wire.read_message(SyncOp) + if sentinel.type != SyncOpType.HEY_YOU_DID_IT: + raise WireError("expected BSDIFF sentinel SyncOp") + + yield FilePatch( + sync_header=sync_header, + bsdiff_header=bsdiff_header, + bsdiff_controls=controls, + ) + file_index += 1 + continue + + if header_type != SyncHeaderType.RSYNC: + raise WireError(f"unsupported sync header type: {header_type}") + + ops: list[SyncOp] = [] + while True: + op = self._wire.read_message(SyncOp) + if op.type == SyncOpType.HEY_YOU_DID_IT: + break + ops.append(op) + + yield FilePatch(sync_header=sync_header, sync_ops=ops) + file_index += 1 + + def close(self) -> None: + if self._wire: + self._wire.close() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + self.close() + + +class SignatureReader: + def __init__(self, stream, *, container_decoder: ContainerDecoder | None = None): + self._stream = stream + self._raw_wire = WireReader(stream) + self._wire: WireReader | None = None + + self.header: SignatureHeader | None = None + self.container_raw: bytes | None = None + self.container: Any | None = None + + self._init_stream(container_decoder) + + @classmethod + def open(cls, path: str, *, container_decoder: ContainerDecoder | None = None): + return cls(open(path, "rb"), container_decoder=container_decoder) + + def _init_stream(self, container_decoder): + self._raw_wire.expect_magic(SIGNATURE_MAGIC) + self.header = self._raw_wire.read_message(SignatureHeader) + + decompressed = open_decompressed_reader(self._stream, self.header.compression) + self._wire = WireReader(decompressed) + + self.container_raw = self._wire.read_message_bytes() + self.container = container_decoder(self.container_raw) if container_decoder else None + + def iter_block_hashes(self) -> Iterator[BlockHash]: + assert self._wire is not None + while True: + try: + yield self._wire.read_message(BlockHash) + except EOFError: + return + + def close(self) -> None: + if self._wire: + self._wire.close() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + self.close() + + +class ManifestReader: + def __init__(self, stream, *, container_decoder: ContainerDecoder | None = None): + self._stream = stream + self._raw_wire = WireReader(stream) + self._wire: WireReader | None = None + + self.header: ManifestHeader | None = None + self.container_raw: bytes | None = None + self.container: Any | None = None + + self._init_stream(container_decoder) + + @classmethod + def open(cls, path: str, *, container_decoder: ContainerDecoder | None = None): + return cls(open(path, "rb"), container_decoder=container_decoder) + + def _init_stream(self, container_decoder): + self._raw_wire.expect_magic(MANIFEST_MAGIC) + self.header = self._raw_wire.read_message(ManifestHeader) + + decompressed = open_decompressed_reader(self._stream, self.header.compression) + self._wire = WireReader(decompressed) + + self.container_raw = self._wire.read_message_bytes() + self.container = container_decoder(self.container_raw) if container_decoder else None + + def iter_block_hashes(self) -> Iterator[ManifestBlockHash]: + assert self._wire is not None + while True: + try: + yield self._wire.read_message(ManifestBlockHash) + except EOFError: + return + + def close(self) -> None: + if self._wire: + self._wire.close() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + self.close() + + +class WoundsReader: + def __init__(self, stream, *, container_decoder: ContainerDecoder | None = None): + self._stream = stream + self._wire = WireReader(stream) + + self.header: WoundsHeader | None = None + self.container_raw: bytes | None = None + self.container: Any | None = None + + self._init_stream(container_decoder) + + @classmethod + def open(cls, path: str, *, container_decoder: ContainerDecoder | None = None): + return cls(open(path, "rb"), container_decoder=container_decoder) + + def _init_stream(self, container_decoder): + self._wire.expect_magic(WOUNDS_MAGIC) + self.header = self._wire.read_message(WoundsHeader) + self.container_raw = self._wire.read_message_bytes() + self.container = container_decoder(self.container_raw) if container_decoder else None + + def iter_wounds(self) -> Iterator[Wound]: + while True: + try: + yield self._wire.read_message(Wound) + except EOFError: + return + + def close(self) -> None: + self._wire.close() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + self.close() diff --git a/pwr/proto.py b/pwr/proto.py new file mode 100644 index 0000000..1319802 --- /dev/null +++ b/pwr/proto.py @@ -0,0 +1,477 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from enum import IntEnum +from typing import Any, ClassVar, Dict, Tuple + + +class ProtoError(Exception): + pass + + +def _unsigned(value: int, bits: int) -> int: + if value < 0: + value = (1 << bits) + value + return value + + +def _signed(value: int, bits: int) -> int: + sign_bit = 1 << (bits - 1) + if value & sign_bit: + return value - (1 << bits) + return value + + +def _encode_varint(value: int) -> bytes: + if value < 0: + raise ProtoError("varint cannot encode negative values") + out = bytearray() + while True: + to_write = value & 0x7F + value >>= 7 + if value: + out.append(to_write | 0x80) + else: + out.append(to_write) + break + return bytes(out) + + +def _encode_key(field_number: int, wire_type: int) -> bytes: + return _encode_varint((field_number << 3) | wire_type) + + +class ProtoReader: + def __init__(self, data: bytes): + self._data = bytes(data) + self._pos = 0 + + def eof(self) -> bool: + return self._pos >= len(self._data) + + def read_varint(self) -> int: + shift = 0 + result = 0 + while True: + if self._pos >= len(self._data): + raise ProtoError("unexpected EOF while reading varint") + byte = self._data[self._pos] + self._pos += 1 + result |= (byte & 0x7F) << shift + if not (byte & 0x80): + return result + shift += 7 + if shift > 64: + raise ProtoError("varint too long") + + def read_key(self) -> Tuple[int, int]: + key = self.read_varint() + return key >> 3, key & 0x07 + + def read_length_delimited(self) -> bytes: + length = self.read_varint() + end = self._pos + length + if end > len(self._data): + raise ProtoError("unexpected EOF while reading length-delimited field") + data = self._data[self._pos:end] + self._pos = end + return data + + def skip(self, wire_type: int) -> None: + if wire_type == 0: + self.read_varint() + return + if wire_type == 1: + self._pos += 8 + return + if wire_type == 2: + length = self.read_varint() + self._pos += length + return + if wire_type == 5: + self._pos += 4 + return + raise ProtoError(f"unsupported wire type: {wire_type}") + + +class ProtoMessage: + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = {} + + def to_bytes(self) -> bytes: + out = bytearray() + for field_number in sorted(self.FIELDS): + name, field_type, extra = self.FIELDS[field_number] + value = getattr(self, name) + if value is None: + continue + + repeated = False + if field_type.startswith("repeated_"): + repeated = True + field_type = field_type[len("repeated_") :] + + values = value if repeated else [value] + for item in values: + if field_type == "message": + if isinstance(item, (bytes, bytearray, memoryview)): + raw = bytes(item) + else: + raw = item.to_bytes() + out.extend(_encode_key(field_number, 2)) + out.extend(_encode_varint(len(raw))) + out.extend(raw) + continue + + if field_type == "bytes": + raw = bytes(item) + out.extend(_encode_key(field_number, 2)) + out.extend(_encode_varint(len(raw))) + out.extend(raw) + continue + + if field_type == "string": + raw = str(item).encode("utf-8") + out.extend(_encode_key(field_number, 2)) + out.extend(_encode_varint(len(raw))) + out.extend(raw) + continue + + if field_type == "bool": + out.extend(_encode_key(field_number, 0)) + out.extend(_encode_varint(1 if item else 0)) + continue + + if field_type == "enum": + if isinstance(item, IntEnum): + item = int(item) + out.extend(_encode_key(field_number, 0)) + out.extend(_encode_varint(_unsigned(int(item), 64))) + continue + + if field_type in ("int32", "int64"): + bits = 32 if field_type == "int32" else 64 + out.extend(_encode_key(field_number, 0)) + out.extend(_encode_varint(_unsigned(int(item), bits))) + continue + + if field_type in ("uint32", "uint64"): + out.extend(_encode_key(field_number, 0)) + out.extend(_encode_varint(int(item))) + continue + + raise ProtoError(f"unsupported field type: {field_type}") + + return bytes(out) + + @classmethod + def from_bytes(cls, data: bytes): + reader = ProtoReader(data) + obj = cls() + while not reader.eof(): + field_number, wire_type = reader.read_key() + spec = cls.FIELDS.get(field_number) + if spec is None: + reader.skip(wire_type) + continue + name, field_type, extra = spec + + repeated = False + if field_type.startswith("repeated_"): + repeated = True + field_type = field_type[len("repeated_") :] + + if field_type == "message": + raw = reader.read_length_delimited() + if extra is None: + value = raw + else: + value = extra.from_bytes(raw) + elif field_type == "bytes": + value = reader.read_length_delimited() + elif field_type == "string": + value = reader.read_length_delimited().decode("utf-8") + elif field_type == "bool": + value = bool(reader.read_varint()) + elif field_type == "enum": + raw_value = reader.read_varint() + if extra is None: + value = raw_value + else: + try: + value = extra(raw_value) + except ValueError: + value = raw_value + elif field_type == "int32": + value = _signed(reader.read_varint(), 32) + elif field_type == "int64": + value = _signed(reader.read_varint(), 64) + elif field_type == "uint32": + value = reader.read_varint() + elif field_type == "uint64": + value = reader.read_varint() + else: + raise ProtoError(f"unsupported field type: {field_type}") + + if repeated: + current = getattr(obj, name, None) + if current is None: + current = [] + setattr(obj, name, current) + current.append(value) + else: + setattr(obj, name, value) + + return obj + + +class CompressionAlgorithm(IntEnum): + NONE = 0 + BROTLI = 1 + GZIP = 2 + ZSTD = 3 + + +class HashAlgorithm(IntEnum): + SHAKE128_32 = 0 + CRC32C = 1 + + +class WoundKind(IntEnum): + FILE = 0 + SYMLINK = 1 + DIR = 2 + CLOSED_FILE = 3 + + +class SyncHeaderType(IntEnum): + RSYNC = 0 + BSDIFF = 1 + + +class SyncOpType(IntEnum): + BLOCK_RANGE = 0 + DATA = 1 + HEY_YOU_DID_IT = 2049 + + +class OverlayOpType(IntEnum): + SKIP = 0 + FRESH = 1 + HEY_YOU_DID_IT = 2040 + + +@dataclass +class CompressionSettings(ProtoMessage): + algorithm: CompressionAlgorithm | int | None = None + quality: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("algorithm", "enum", CompressionAlgorithm), + 2: ("quality", "int32", None), + } + + +@dataclass +class PatchHeader(ProtoMessage): + compression: CompressionSettings | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("compression", "message", CompressionSettings), + } + + +@dataclass +class SyncHeader(ProtoMessage): + type: SyncHeaderType | int | None = None + file_index: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("type", "enum", SyncHeaderType), + 16: ("file_index", "int64", None), + } + + +@dataclass +class BsdiffHeader(ProtoMessage): + target_index: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("target_index", "int64", None), + } + + +@dataclass +class SyncOp(ProtoMessage): + type: SyncOpType | int | None = None + file_index: int | None = None + block_index: int | None = None + block_span: int | None = None + data: bytes | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("type", "enum", SyncOpType), + 2: ("file_index", "int64", None), + 3: ("block_index", "int64", None), + 4: ("block_span", "int64", None), + 5: ("data", "bytes", None), + } + + +@dataclass +class SignatureHeader(ProtoMessage): + compression: CompressionSettings | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("compression", "message", CompressionSettings), + } + + +@dataclass +class BlockHash(ProtoMessage): + weak_hash: int | None = None + strong_hash: bytes | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("weak_hash", "uint32", None), + 2: ("strong_hash", "bytes", None), + } + + +@dataclass +class ManifestHeader(ProtoMessage): + compression: CompressionSettings | None = None + algorithm: HashAlgorithm | int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("compression", "message", CompressionSettings), + 2: ("algorithm", "enum", HashAlgorithm), + } + + +@dataclass +class ManifestBlockHash(ProtoMessage): + hash: bytes | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("hash", "bytes", None), + } + + +@dataclass +class WoundsHeader(ProtoMessage): + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = {} + + +@dataclass +class Wound(ProtoMessage): + index: int | None = None + start: int | None = None + end: int | None = None + kind: WoundKind | int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("index", "int64", None), + 2: ("start", "int64", None), + 3: ("end", "int64", None), + 4: ("kind", "enum", WoundKind), + } + + +@dataclass +class Control(ProtoMessage): + add: bytes | None = None + copy: bytes | None = None + seek: int | None = None + eof: bool | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("add", "bytes", None), + 2: ("copy", "bytes", None), + 3: ("seek", "int64", None), + 4: ("eof", "bool", None), + } + + +@dataclass +class OverlayHeader(ProtoMessage): + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = {} + + +@dataclass +class OverlayOp(ProtoMessage): + type: OverlayOpType | int | None = None + len: int | None = None + data: bytes | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("type", "enum", OverlayOpType), + 2: ("len", "int64", None), + 3: ("data", "bytes", None), + } + + +@dataclass +class Sample(ProtoMessage): + data: bytes | None = None + number: int | None = None + eof: bool | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("data", "bytes", None), + 2: ("number", "int64", None), + 3: ("eof", "bool", None), + } + + +@dataclass +class TlcDir(ProtoMessage): + path: str | None = None + mode: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("path", "string", None), + 2: ("mode", "uint32", None), + } + + +@dataclass +class TlcFile(ProtoMessage): + path: str | None = None + mode: int | None = None + size: int | None = None + offset: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("path", "string", None), + 2: ("mode", "uint32", None), + 3: ("size", "int64", None), + 4: ("offset", "int64", None), + } + + +@dataclass +class TlcSymlink(ProtoMessage): + path: str | None = None + mode: int | None = None + dest: str | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("path", "string", None), + 2: ("mode", "uint32", None), + 3: ("dest", "string", None), + } + + +@dataclass +class TlcContainer(ProtoMessage): + files: list[TlcFile] = field(default_factory=list) + dirs: list[TlcDir] = field(default_factory=list) + symlinks: list[TlcSymlink] = field(default_factory=list) + size: int | None = None + + FIELDS: ClassVar[Dict[int, Tuple[str, str, Any]]] = { + 1: ("files", "repeated_message", TlcFile), + 2: ("dirs", "repeated_message", TlcDir), + 3: ("symlinks", "repeated_message", TlcSymlink), + 16: ("size", "int64", None), + } diff --git a/pwr/wire.py b/pwr/wire.py new file mode 100644 index 0000000..f99d813 --- /dev/null +++ b/pwr/wire.py @@ -0,0 +1,140 @@ +from __future__ import annotations + +import io +import struct +from typing import BinaryIO, Type, TypeVar + +from .proto import ProtoError, ProtoMessage + +PATCH_MAGIC = 0xFEF5F00 +SIGNATURE_MAGIC = PATCH_MAGIC + 1 +MANIFEST_MAGIC = PATCH_MAGIC + 2 +WOUNDS_MAGIC = PATCH_MAGIC + 3 +ZIP_INDEX_MAGIC = PATCH_MAGIC + 4 + +BLOCK_SIZE = 64 * 1024 + + +class WireError(Exception): + pass + + +def _read_exact(stream: BinaryIO, size: int) -> bytes: + if size <= 0: + return b"" + try: + data = stream.read(size) + if data is not None: + return data + except NotImplementedError: + pass + + readinto = getattr(stream, "readinto", None) + if readinto is None: + raise WireError("stream does not support read or readinto") + + buf = bytearray(size) + view = memoryview(buf) + total = 0 + while total < size: + n = readinto(view[total:]) + if n is None: + n = 0 + if n == 0: + break + total += n + return bytes(view[:total]) + + +def read_varint(stream: BinaryIO) -> int: + shift = 0 + result = 0 + while True: + b = _read_exact(stream, 1) + if not b: + raise EOFError("unexpected EOF while reading varint") + byte = b[0] + result |= (byte & 0x7F) << shift + if not (byte & 0x80): + return result + shift += 7 + if shift > 64: + raise WireError("varint too long") + + +def write_varint(stream: BinaryIO, value: int) -> None: + if value < 0: + raise WireError("varint cannot encode negative values") + while True: + to_write = value & 0x7F + value >>= 7 + if value: + stream.write(bytes([to_write | 0x80])) + else: + stream.write(bytes([to_write])) + break + + +def read_magic(stream: BinaryIO) -> int: + data = _read_exact(stream, 4) + if len(data) != 4: + raise EOFError("unexpected EOF while reading magic") + return struct.unpack(" None: + stream.write(struct.pack(" int: + return read_magic(self._stream) + + def expect_magic(self, magic: int) -> None: + found = self.read_magic() + if found != magic: + raise WireError(f"wrong magic: expected {magic}, got {found}") + + def read_message_bytes(self) -> bytes: + length = read_varint(self._stream) + data = _read_exact(self._stream, length) + if len(data) != length: + raise EOFError("unexpected EOF while reading message") + return data + + def read_message(self, msg_cls: Type[T]) -> T: + data = self.read_message_bytes() + try: + return msg_cls.from_bytes(data) + except ProtoError as exc: + raise WireError(str(exc)) from exc + + def close(self) -> None: + if isinstance(self._stream, io.IOBase): + self._stream.close() + + +class WireWriter: + def __init__(self, stream: BinaryIO): + self._stream = stream + + def write_magic(self, magic: int) -> None: + write_magic(self._stream, magic) + + def write_message(self, msg: ProtoMessage | bytes | bytearray | memoryview) -> None: + if isinstance(msg, (bytes, bytearray, memoryview)): + data = bytes(msg) + else: + data = msg.to_bytes() + write_varint(self._stream, len(data)) + self._stream.write(data) + + def close(self) -> None: + if isinstance(self._stream, io.IOBase): + self._stream.close() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..a23adb5 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,10 @@ +[project] +name = "py-pwr" +version = "0.1.0" +description = "Python client for wharf/pwr wire formats" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "brotli>=1.2.0", + "zstandard>=0.25.0", +] diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..1af353a --- /dev/null +++ b/uv.lock @@ -0,0 +1,113 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" + +[[package]] +name = "brotli" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" }, + { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" }, + { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" }, + { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" }, + { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" }, + { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" }, + { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" }, + { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" }, + { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" }, + { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" }, + { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" }, + { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" }, + { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" }, + { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" }, + { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" }, + { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" }, + { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" }, + { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" }, + { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" }, + { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" }, + { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" }, +] + +[[package]] +name = "py-pwr" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "brotli" }, + { name = "zstandard" }, +] + +[package.metadata] +requires-dist = [ + { name = "brotli", specifier = ">=1.2.0" }, + { name = "zstandard", specifier = ">=0.25.0" }, +] + +[[package]] +name = "zstandard" +version = "0.25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/aa/3e0508d5a5dd96529cdc5a97011299056e14c6505b678fd58938792794b1/zstandard-0.25.0.tar.gz", hash = "sha256:7713e1179d162cf5c7906da876ec2ccb9c3a9dcbdffef0cc7f70c3667a205f0b", size = 711513, upload-time = "2025-09-14T22:15:54.002Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/fc/f26eb6ef91ae723a03e16eddb198abcfce2bc5a42e224d44cc8b6765e57e/zstandard-0.25.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7b3c3a3ab9daa3eed242d6ecceead93aebbb8f5f84318d82cee643e019c4b73b", size = 795738, upload-time = "2025-09-14T22:16:56.237Z" }, + { url = "https://files.pythonhosted.org/packages/aa/1c/d920d64b22f8dd028a8b90e2d756e431a5d86194caa78e3819c7bf53b4b3/zstandard-0.25.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:913cbd31a400febff93b564a23e17c3ed2d56c064006f54efec210d586171c00", size = 640436, upload-time = "2025-09-14T22:16:57.774Z" }, + { url = "https://files.pythonhosted.org/packages/53/6c/288c3f0bd9fcfe9ca41e2c2fbfd17b2097f6af57b62a81161941f09afa76/zstandard-0.25.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:011d388c76b11a0c165374ce660ce2c8efa8e5d87f34996aa80f9c0816698b64", size = 5343019, upload-time = "2025-09-14T22:16:59.302Z" }, + { url = "https://files.pythonhosted.org/packages/1e/15/efef5a2f204a64bdb5571e6161d49f7ef0fffdbca953a615efbec045f60f/zstandard-0.25.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dffecc361d079bb48d7caef5d673c88c8988d3d33fb74ab95b7ee6da42652ea", size = 5063012, upload-time = "2025-09-14T22:17:01.156Z" }, + { url = "https://files.pythonhosted.org/packages/b7/37/a6ce629ffdb43959e92e87ebdaeebb5ac81c944b6a75c9c47e300f85abdf/zstandard-0.25.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7149623bba7fdf7e7f24312953bcf73cae103db8cae49f8154dd1eadc8a29ecb", size = 5394148, upload-time = "2025-09-14T22:17:03.091Z" }, + { url = "https://files.pythonhosted.org/packages/e3/79/2bf870b3abeb5c070fe2d670a5a8d1057a8270f125ef7676d29ea900f496/zstandard-0.25.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a573a35693e03cf1d67799fd01b50ff578515a8aeadd4595d2a7fa9f3ec002a", size = 5451652, upload-time = "2025-09-14T22:17:04.979Z" }, + { url = "https://files.pythonhosted.org/packages/53/60/7be26e610767316c028a2cbedb9a3beabdbe33e2182c373f71a1c0b88f36/zstandard-0.25.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5a56ba0db2d244117ed744dfa8f6f5b366e14148e00de44723413b2f3938a902", size = 5546993, upload-time = "2025-09-14T22:17:06.781Z" }, + { url = "https://files.pythonhosted.org/packages/85/c7/3483ad9ff0662623f3648479b0380d2de5510abf00990468c286c6b04017/zstandard-0.25.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:10ef2a79ab8e2974e2075fb984e5b9806c64134810fac21576f0668e7ea19f8f", size = 5046806, upload-time = "2025-09-14T22:17:08.415Z" }, + { url = "https://files.pythonhosted.org/packages/08/b3/206883dd25b8d1591a1caa44b54c2aad84badccf2f1de9e2d60a446f9a25/zstandard-0.25.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aaf21ba8fb76d102b696781bddaa0954b782536446083ae3fdaa6f16b25a1c4b", size = 5576659, upload-time = "2025-09-14T22:17:10.164Z" }, + { url = "https://files.pythonhosted.org/packages/9d/31/76c0779101453e6c117b0ff22565865c54f48f8bd807df2b00c2c404b8e0/zstandard-0.25.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1869da9571d5e94a85a5e8d57e4e8807b175c9e4a6294e3b66fa4efb074d90f6", size = 4953933, upload-time = "2025-09-14T22:17:11.857Z" }, + { url = "https://files.pythonhosted.org/packages/18/e1/97680c664a1bf9a247a280a053d98e251424af51f1b196c6d52f117c9720/zstandard-0.25.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:809c5bcb2c67cd0ed81e9229d227d4ca28f82d0f778fc5fea624a9def3963f91", size = 5268008, upload-time = "2025-09-14T22:17:13.627Z" }, + { url = "https://files.pythonhosted.org/packages/1e/73/316e4010de585ac798e154e88fd81bb16afc5c5cb1a72eeb16dd37e8024a/zstandard-0.25.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f27662e4f7dbf9f9c12391cb37b4c4c3cb90ffbd3b1fb9284dadbbb8935fa708", size = 5433517, upload-time = "2025-09-14T22:17:16.103Z" }, + { url = "https://files.pythonhosted.org/packages/5b/60/dd0f8cfa8129c5a0ce3ea6b7f70be5b33d2618013a161e1ff26c2b39787c/zstandard-0.25.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:99c0c846e6e61718715a3c9437ccc625de26593fea60189567f0118dc9db7512", size = 5814292, upload-time = "2025-09-14T22:17:17.827Z" }, + { url = "https://files.pythonhosted.org/packages/fc/5f/75aafd4b9d11b5407b641b8e41a57864097663699f23e9ad4dbb91dc6bfe/zstandard-0.25.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:474d2596a2dbc241a556e965fb76002c1ce655445e4e3bf38e5477d413165ffa", size = 5360237, upload-time = "2025-09-14T22:17:19.954Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8d/0309daffea4fcac7981021dbf21cdb2e3427a9e76bafbcdbdf5392ff99a4/zstandard-0.25.0-cp312-cp312-win32.whl", hash = "sha256:23ebc8f17a03133b4426bcc04aabd68f8236eb78c3760f12783385171b0fd8bd", size = 436922, upload-time = "2025-09-14T22:17:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/79/3b/fa54d9015f945330510cb5d0b0501e8253c127cca7ebe8ba46a965df18c5/zstandard-0.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:ffef5a74088f1e09947aecf91011136665152e0b4b359c42be3373897fb39b01", size = 506276, upload-time = "2025-09-14T22:17:21.429Z" }, + { url = "https://files.pythonhosted.org/packages/ea/6b/8b51697e5319b1f9ac71087b0af9a40d8a6288ff8025c36486e0c12abcc4/zstandard-0.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:181eb40e0b6a29b3cd2849f825e0fa34397f649170673d385f3598ae17cca2e9", size = 462679, upload-time = "2025-09-14T22:17:23.147Z" }, + { url = "https://files.pythonhosted.org/packages/35/0b/8df9c4ad06af91d39e94fa96cc010a24ac4ef1378d3efab9223cc8593d40/zstandard-0.25.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec996f12524f88e151c339688c3897194821d7f03081ab35d31d1e12ec975e94", size = 795735, upload-time = "2025-09-14T22:17:26.042Z" }, + { url = "https://files.pythonhosted.org/packages/3f/06/9ae96a3e5dcfd119377ba33d4c42a7d89da1efabd5cb3e366b156c45ff4d/zstandard-0.25.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1a4ae2dec3993a32247995bdfe367fc3266da832d82f8438c8570f989753de1", size = 640440, upload-time = "2025-09-14T22:17:27.366Z" }, + { url = "https://files.pythonhosted.org/packages/d9/14/933d27204c2bd404229c69f445862454dcc101cd69ef8c6068f15aaec12c/zstandard-0.25.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:e96594a5537722fdfb79951672a2a63aec5ebfb823e7560586f7484819f2a08f", size = 5343070, upload-time = "2025-09-14T22:17:28.896Z" }, + { url = "https://files.pythonhosted.org/packages/6d/db/ddb11011826ed7db9d0e485d13df79b58586bfdec56e5c84a928a9a78c1c/zstandard-0.25.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bfc4e20784722098822e3eee42b8e576b379ed72cca4a7cb856ae733e62192ea", size = 5063001, upload-time = "2025-09-14T22:17:31.044Z" }, + { url = "https://files.pythonhosted.org/packages/db/00/87466ea3f99599d02a5238498b87bf84a6348290c19571051839ca943777/zstandard-0.25.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:457ed498fc58cdc12fc48f7950e02740d4f7ae9493dd4ab2168a47c93c31298e", size = 5394120, upload-time = "2025-09-14T22:17:32.711Z" }, + { url = "https://files.pythonhosted.org/packages/2b/95/fc5531d9c618a679a20ff6c29e2b3ef1d1f4ad66c5e161ae6ff847d102a9/zstandard-0.25.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fd7a5004eb1980d3cefe26b2685bcb0b17989901a70a1040d1ac86f1d898c551", size = 5451230, upload-time = "2025-09-14T22:17:34.41Z" }, + { url = "https://files.pythonhosted.org/packages/63/4b/e3678b4e776db00f9f7b2fe58e547e8928ef32727d7a1ff01dea010f3f13/zstandard-0.25.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e735494da3db08694d26480f1493ad2cf86e99bdd53e8e9771b2752a5c0246a", size = 5547173, upload-time = "2025-09-14T22:17:36.084Z" }, + { url = "https://files.pythonhosted.org/packages/4e/d5/ba05ed95c6b8ec30bd468dfeab20589f2cf709b5c940483e31d991f2ca58/zstandard-0.25.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3a39c94ad7866160a4a46d772e43311a743c316942037671beb264e395bdd611", size = 5046736, upload-time = "2025-09-14T22:17:37.891Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/870aa06b3a76c73eced65c044b92286a3c4e00554005ff51962deef28e28/zstandard-0.25.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:172de1f06947577d3a3005416977cce6168f2261284c02080e7ad0185faeced3", size = 5576368, upload-time = "2025-09-14T22:17:40.206Z" }, + { url = "https://files.pythonhosted.org/packages/5d/35/398dc2ffc89d304d59bc12f0fdd931b4ce455bddf7038a0a67733a25f550/zstandard-0.25.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3c83b0188c852a47cd13ef3bf9209fb0a77fa5374958b8c53aaa699398c6bd7b", size = 4954022, upload-time = "2025-09-14T22:17:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/9a/5c/36ba1e5507d56d2213202ec2b05e8541734af5f2ce378c5d1ceaf4d88dc4/zstandard-0.25.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1673b7199bbe763365b81a4f3252b8e80f44c9e323fc42940dc8843bfeaf9851", size = 5267889, upload-time = "2025-09-14T22:17:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/70/e8/2ec6b6fb7358b2ec0113ae202647ca7c0e9d15b61c005ae5225ad0995df5/zstandard-0.25.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0be7622c37c183406f3dbf0cba104118eb16a4ea7359eeb5752f0794882fc250", size = 5433952, upload-time = "2025-09-14T22:17:45.271Z" }, + { url = "https://files.pythonhosted.org/packages/7b/01/b5f4d4dbc59ef193e870495c6f1275f5b2928e01ff5a81fecb22a06e22fb/zstandard-0.25.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:5f5e4c2a23ca271c218ac025bd7d635597048b366d6f31f420aaeb715239fc98", size = 5814054, upload-time = "2025-09-14T22:17:47.08Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/fbd822d5c6f427cf158316d012c5a12f233473c2f9c5fe5ab1ae5d21f3d8/zstandard-0.25.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f187a0bb61b35119d1926aee039524d1f93aaf38a9916b8c4b78ac8514a0aaf", size = 5360113, upload-time = "2025-09-14T22:17:48.893Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/69a553d2047f9a2c7347caa225bb3a63b6d7704ad74610cb7823baa08ed7/zstandard-0.25.0-cp313-cp313-win32.whl", hash = "sha256:7030defa83eef3e51ff26f0b7bfb229f0204b66fe18e04359ce3474ac33cbc09", size = 436936, upload-time = "2025-09-14T22:17:52.658Z" }, + { url = "https://files.pythonhosted.org/packages/d9/82/b9c06c870f3bd8767c201f1edbdf9e8dc34be5b0fbc5682c4f80fe948475/zstandard-0.25.0-cp313-cp313-win_amd64.whl", hash = "sha256:1f830a0dac88719af0ae43b8b2d6aef487d437036468ef3c2ea59c51f9d55fd5", size = 506232, upload-time = "2025-09-14T22:17:50.402Z" }, + { url = "https://files.pythonhosted.org/packages/d4/57/60c3c01243bb81d381c9916e2a6d9e149ab8627c0c7d7abb2d73384b3c0c/zstandard-0.25.0-cp313-cp313-win_arm64.whl", hash = "sha256:85304a43f4d513f5464ceb938aa02c1e78c2943b29f44a750b48b25ac999a049", size = 462671, upload-time = "2025-09-14T22:17:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/3d/5c/f8923b595b55fe49e30612987ad8bf053aef555c14f05bb659dd5dbe3e8a/zstandard-0.25.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e29f0cf06974c899b2c188ef7f783607dbef36da4c242eb6c82dcd8b512855e3", size = 795887, upload-time = "2025-09-14T22:17:54.198Z" }, + { url = "https://files.pythonhosted.org/packages/8d/09/d0a2a14fc3439c5f874042dca72a79c70a532090b7ba0003be73fee37ae2/zstandard-0.25.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:05df5136bc5a011f33cd25bc9f506e7426c0c9b3f9954f056831ce68f3b6689f", size = 640658, upload-time = "2025-09-14T22:17:55.423Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/8b6b71b1ddd517f68ffb55e10834388d4f793c49c6b83effaaa05785b0b4/zstandard-0.25.0-cp314-cp314-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:f604efd28f239cc21b3adb53eb061e2a205dc164be408e553b41ba2ffe0ca15c", size = 5379849, upload-time = "2025-09-14T22:17:57.372Z" }, + { url = "https://files.pythonhosted.org/packages/a4/86/a48e56320d0a17189ab7a42645387334fba2200e904ee47fc5a26c1fd8ca/zstandard-0.25.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223415140608d0f0da010499eaa8ccdb9af210a543fac54bce15babbcfc78439", size = 5058095, upload-time = "2025-09-14T22:17:59.498Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ad/eb659984ee2c0a779f9d06dbfe45e2dc39d99ff40a319895df2d3d9a48e5/zstandard-0.25.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e54296a283f3ab5a26fc9b8b5d4978ea0532f37b231644f367aa588930aa043", size = 5551751, upload-time = "2025-09-14T22:18:01.618Z" }, + { url = "https://files.pythonhosted.org/packages/61/b3/b637faea43677eb7bd42ab204dfb7053bd5c4582bfe6b1baefa80ac0c47b/zstandard-0.25.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ca54090275939dc8ec5dea2d2afb400e0f83444b2fc24e07df7fdef677110859", size = 6364818, upload-time = "2025-09-14T22:18:03.769Z" }, + { url = "https://files.pythonhosted.org/packages/31/dc/cc50210e11e465c975462439a492516a73300ab8caa8f5e0902544fd748b/zstandard-0.25.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e09bb6252b6476d8d56100e8147b803befa9a12cea144bbe629dd508800d1ad0", size = 5560402, upload-time = "2025-09-14T22:18:05.954Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ae/56523ae9c142f0c08efd5e868a6da613ae76614eca1305259c3bf6a0ed43/zstandard-0.25.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a9ec8c642d1ec73287ae3e726792dd86c96f5681eb8df274a757bf62b750eae7", size = 4955108, upload-time = "2025-09-14T22:18:07.68Z" }, + { url = "https://files.pythonhosted.org/packages/98/cf/c899f2d6df0840d5e384cf4c4121458c72802e8bda19691f3b16619f51e9/zstandard-0.25.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4089a10e598eae6393756b036e0f419e8c1d60f44a831520f9af41c14216cf2", size = 5269248, upload-time = "2025-09-14T22:18:09.753Z" }, + { url = "https://files.pythonhosted.org/packages/1b/c0/59e912a531d91e1c192d3085fc0f6fb2852753c301a812d856d857ea03c6/zstandard-0.25.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f67e8f1a324a900e75b5e28ffb152bcac9fbed1cc7b43f99cd90f395c4375344", size = 5430330, upload-time = "2025-09-14T22:18:11.966Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/7e31db1240de2df22a58e2ea9a93fc6e38cc29353e660c0272b6735d6669/zstandard-0.25.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9654dbc012d8b06fc3d19cc825af3f7bf8ae242226df5f83936cb39f5fdc846c", size = 5811123, upload-time = "2025-09-14T22:18:13.907Z" }, + { url = "https://files.pythonhosted.org/packages/f6/49/fac46df5ad353d50535e118d6983069df68ca5908d4d65b8c466150a4ff1/zstandard-0.25.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4203ce3b31aec23012d3a4cf4a2ed64d12fea5269c49aed5e4c3611b938e4088", size = 5359591, upload-time = "2025-09-14T22:18:16.465Z" }, + { url = "https://files.pythonhosted.org/packages/c2/38/f249a2050ad1eea0bb364046153942e34abba95dd5520af199aed86fbb49/zstandard-0.25.0-cp314-cp314-win32.whl", hash = "sha256:da469dc041701583e34de852d8634703550348d5822e66a0c827d39b05365b12", size = 444513, upload-time = "2025-09-14T22:18:20.61Z" }, + { url = "https://files.pythonhosted.org/packages/3a/43/241f9615bcf8ba8903b3f0432da069e857fc4fd1783bd26183db53c4804b/zstandard-0.25.0-cp314-cp314-win_amd64.whl", hash = "sha256:c19bcdd826e95671065f8692b5a4aa95c52dc7a02a4c5a0cac46deb879a017a2", size = 516118, upload-time = "2025-09-14T22:18:17.849Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ef/da163ce2450ed4febf6467d77ccb4cd52c4c30ab45624bad26ca0a27260c/zstandard-0.25.0-cp314-cp314-win_arm64.whl", hash = "sha256:d7541afd73985c630bafcd6338d2518ae96060075f9463d7dc14cfb33514383d", size = 476940, upload-time = "2025-09-14T22:18:19.088Z" }, +]