hdiffpatch 1.1.0__cp314-cp314-win_amd64.whl

hdiffpatch/_zlib_config.py

@@ -0,0 +1,177 @@
+"""ZlibConfig class for configuring zlib compression parameters."""
+
+from enum import Enum
+from typing import Union
+
+import attrs
+
+from ._base_config import BaseConfig
+
+
+class ZlibStrategy(Enum):
+    """Zlib compression strategies."""
+
+    DEFAULT = "default"
+    FILTERED = "filtered"
+    HUFFMAN_ONLY = "huffman_only"
+    RLE = "rle"
+    FIXED = "fixed"
+
+
+def _convert_strategy(value: Union[ZlibStrategy, str]) -> ZlibStrategy:
+    """Convert and validate strategy parameter.
+
+    Parameters
+    ----------
+    value : ZlibStrategy or str
+        The strategy value to convert
+
+    Returns
+    -------
+    ZlibStrategy
+        The validated strategy enum
+
+    Raises
+    ------
+    TypeError
+        If value is not a ZlibStrategy enum or string
+    ValueError
+        If string value is not a valid strategy
+    """
+    if isinstance(value, str):
+        try:
+            return ZlibStrategy(value.lower())
+        except ValueError:
+            valid_strategies = [s.value for s in ZlibStrategy]
+            raise ValueError(f"Invalid strategy '{value}'. Valid options: {valid_strategies}") from None
+    elif isinstance(value, ZlibStrategy):
+        return value
+    else:
+        raise TypeError("strategy must be a ZlibStrategy enum or string")
+
+
+@attrs.frozen
+class ZlibConfig(BaseConfig):
+    """Configuration for zlib compression parameters.
+
+    This class allows fine-grained control over zlib compression behavior,
+    including compression level, memory usage, window size, and strategy.
+
+    Parameters
+    ----------
+    level : int, default=9
+        Compression level (0-9). Higher values give better
+        compression but are slower. 0 = no compression, 9 = best compression.
+    memory_level : int, default=8
+        Memory level (1-9). Higher values use more memory but
+        may improve compression speed.
+    window : int, default=15
+        Window size as power of 2 (9-15). Larger windows give
+        better compression but use more memory. (32KB window)
+    strategy : ZlibStrategy, default=ZlibStrategy.DEFAULT
+        Compression strategy optimized for different data types.
+    save_window_bits : bool, default=True
+        Whether to save window bits in compressed data header.
+
+    Examples
+    --------
+    Fast compression with minimal memory usage
+
+    >>> config = ZlibConfig(level=1, memory_level=1, window=9)
+
+    Best compression for text data
+
+    >>> config = ZlibConfig(level=9, strategy=ZlibStrategy.DEFAULT)
+
+    Optimized for PNG-like data
+
+    >>> config = ZlibConfig(strategy=ZlibStrategy.RLE)
+    """
+
+    level: int = attrs.field(
+        default=9,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(0),
+            attrs.validators.le(9),
+        ),
+    )
+    memory_level: int = attrs.field(
+        default=8,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(1),
+            attrs.validators.le(9),
+        ),
+    )
+    window: int = attrs.field(
+        default=15,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(9),
+            attrs.validators.le(15),
+        ),
+    )
+    strategy: ZlibStrategy = attrs.field(
+        default=ZlibStrategy.DEFAULT,
+        converter=_convert_strategy,
+    )
+    save_window_bits: bool = attrs.field(
+        default=True,
+        converter=bool,
+    )
+
+    @classmethod
+    def fast(cls) -> "ZlibConfig":
+        """Create a ZlibConfig optimized for speed.
+
+        Returns
+        -------
+        ZlibConfig
+            Configuration optimized for speed
+        """
+        return cls(level=1, memory_level=1, window=9)
+
+    @classmethod
+    def balanced(cls) -> "ZlibConfig":
+        """Create a ZlibConfig with balanced speed/compression.
+
+        Returns
+        -------
+        ZlibConfig
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(level=6, memory_level=8, window=15)
+
+    @classmethod
+    def best_compression(cls) -> "ZlibConfig":
+        """Create a ZlibConfig optimized for best compression.
+
+        Returns
+        -------
+        ZlibConfig
+            Configuration optimized for best compression
+        """
+        return cls(level=9, memory_level=9, window=15)
+
+    @classmethod
+    def minimal_memory(cls) -> "ZlibConfig":
+        """Create a ZlibConfig with minimal memory usage.
+
+        Returns
+        -------
+        ZlibConfig
+            Configuration with minimal memory usage
+        """
+        return cls(level=6, memory_level=1, window=9)
+
+    @classmethod
+    def png_optimized(cls) -> "ZlibConfig":
+        """Create a ZlibConfig optimized for PNG-like data.
+
+        Returns
+        -------
+        ZlibConfig
+            Configuration optimized for PNG-like data
+        """
+        return cls(level=9, strategy=ZlibStrategy.RLE)

hdiffpatch/_zstd_config.py

@@ -0,0 +1,113 @@
+"""ZStdConfig class for configuring zstd compression parameters."""
+
+from typing import Optional
+
+import attrs
+
+from ._base_config import BaseConfig
+
+
+@attrs.frozen
+class ZStdConfig(BaseConfig):
+    """Configuration for zstd compression parameters.
+
+    This class allows control over zstd compression behavior,
+    including compression level, window size, and threading.
+
+    Parameters
+    ----------
+    level : int, default=3
+        Compression level (1-22). Higher values give better
+        compression but are slower. 1 = fastest, 22 = best compression.
+    window : int or None, default=None
+        Window size as log2. Must be between 10 and 27.
+        Larger windows give better compression but use more memory.
+        None uses zstd default based on compression level.
+    workers : int, default=0
+        Number of worker threads (0-200). 0 = single-threaded.
+
+    Examples
+    --------
+    Fast compression with minimal memory usage
+
+    >>> config = ZStdConfig(level=1, workers=0)
+
+    Best compression for large files with multiple threads
+
+    >>> config = ZStdConfig(level=22, workers=4)
+
+    Balanced compression with custom window size
+
+    >>> config = ZStdConfig(level=6, window=20, workers=2)
+    """
+
+    level: int = attrs.field(
+        default=3,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(1),
+            attrs.validators.le(22),
+        ),
+    )
+    window: Optional[int] = attrs.field(
+        default=None,
+        validator=attrs.validators.optional(
+            attrs.validators.and_(
+                attrs.validators.instance_of(int),
+                attrs.validators.ge(10),
+                attrs.validators.le(27),
+            )
+        ),
+    )
+    workers: int = attrs.field(
+        default=0,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(0),
+            attrs.validators.le(200),
+        ),
+    )
+
+    @classmethod
+    def fast(cls) -> "ZStdConfig":
+        """Create a ZStdConfig optimized for speed.
+
+        Returns
+        -------
+        ZStdConfig
+            Configuration optimized for speed
+        """
+        return cls(level=1, workers=0)
+
+    @classmethod
+    def balanced(cls) -> "ZStdConfig":
+        """Create a ZStdConfig with balanced speed/compression.
+
+        Returns
+        -------
+        ZStdConfig
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(level=6, workers=2)
+
+    @classmethod
+    def best_compression(cls) -> "ZStdConfig":
+        """Create a ZStdConfig optimized for best compression.
+
+        Returns
+        -------
+        ZStdConfig
+            Configuration optimized for best compression
+        """
+        return cls(level=22, window=27, workers=4)
+
+    @classmethod
+    def minimal_memory(cls) -> "ZStdConfig":
+        """Create a ZStdConfig with minimal memory usage.
+
+        Returns
+        -------
+        ZStdConfig
+            Configuration with minimal memory usage
+        """
+        return cls(level=3, window=10, workers=0)

hdiffpatch-1.1.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-6z3wtab3\\cp314-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-6z3wtab3\\cp314-win_amd64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-6z3wtab3\\cp314-win_amd64\\built_wheel\\hdiffpatch-1.1.0-cp314-cp314-win_amd64.whl']

hdiffpatch-1.1.0.dist-info/METADATA

@@ -0,0 +1,377 @@
+Metadata-Version: 2.4
+Name: hdiffpatch
+Version: 1.1.0
+Summary: Python wrapper around HDiffPatch C++ library for efficient binary diff/patch operations.
+Author: Brian Pugh
+License-Expression: Apache-2.0
+Project-URL: homepage, https://github.com/BrianPugh/hdiffpatch-python
+Project-URL: repository, https://github.com/BrianPugh/hdiffpatch-python
+Keywords: binary,diff,patch,compression,hdiffpatch,delta,update
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Archiving :: Compression
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs>=21.3.0
+Dynamic: license-file
+
+**hdiffpatch-python** is a Python wrapper around the [HDiffPatch](https://github.com/sisong/HDiffPatch) C++ library, providing binary diff and patch operations with compression support.
+
+<div align="center">
+
+![Python compat](https://img.shields.io/badge/%3E=python-3.9-blue.svg)
+[![PyPi](https://img.shields.io/pypi/v/hdiffpatch.svg)](https://pypi.python.org/pypi/hdiffpatch)
+[![GHA Status](https://github.com/BrianPugh/hdiffpatch-python/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/BrianPugh/hdiffpatch-python/actions?query=workflow%3Atests)
+[![Coverage](https://codecov.io/github/BrianPugh/hdiffpatch-python/coverage.svg?branch=main)](https://codecov.io/github/BrianPugh/hdiffpatch-python?branch=main)
+
+</div>
+
+## Installation
+
+**hdiffpatch** requires Python `>=3.9` and can be installed via:
+
+```bash
+pip install hdiffpatch
+```
+
+For development installation:
+
+```bash
+git clone https://github.com/BrianPugh/hdiffpatch-python.git
+cd hdiffpatch-python
+uv sync
+uv run python rebuild.py  # Build Cython extensions
+```
+
+## Quick Start
+
+**hdiffpatch** primarily provides 2 simple functions:
+
+* `diff` for creating a patch.
+* `apply` for applying a patch.
+
+### Basic Usage
+
+```python
+import hdiffpatch
+
+# Create binary data
+old_data = b"Hello, world!"
+new_data = b"Hello, HDiffPatch!"
+
+# Create a diff
+diff = hdiffpatch.diff(old_data, new_data)
+
+# Apply the diff
+result = hdiffpatch.apply(old_data, diff)
+assert result == new_data
+```
+
+### With Simple Compression
+
+```python
+import hdiffpatch
+
+old_data = b"Large binary data..." * 1000
+new_data = b"Modified binary data..." * 1000
+
+# Create a compressed diff
+diff = hdiffpatch.diff(old_data, new_data, compression="zlib")
+
+# Apply patch
+result = hdiffpatch.apply(old_data, diff)
+assert result == new_data
+```
+
+### With Advanced Compression Configuration
+
+```python
+import hdiffpatch
+
+old_data = b"Large binary data..." * 1000
+new_data = b"Modified binary data..." * 1000
+
+# Use configuration classes for fine-grained control
+config = hdiffpatch.ZlibConfig(level=9, window=12)
+
+diff = hdiffpatch.diff(old_data, new_data, compression=config)
+result = hdiffpatch.apply(old_data, diff)
+assert result == new_data
+```
+
+### Recompressing Diffs
+
+```python
+import hdiffpatch
+
+old_data = b"Large binary data..." * 1000
+new_data = b"Modified binary data..." * 1000
+
+# Create a diff with zlib compression
+diff_zlib = hdiffpatch.diff(old_data, new_data, compression="zlib")
+
+# Recompress the same diff with zstd
+diff_zstd = hdiffpatch.recompress(diff_zlib, compression="zstd")
+
+# Remove compression entirely
+diff_uncompressed = hdiffpatch.recompress(diff_zlib, compression="none")
+
+# Both diffs produce the same result when applied
+result1 = hdiffpatch.apply(old_data, diff_zlib)
+result2 = hdiffpatch.apply(old_data, diff_zstd)
+assert result1 == result2 == new_data
+```
+
+## API Reference
+
+### Core Functions
+
+```python
+def diff(old_data, new_data, compression="none", *, validate=True) -> bytes
+```
+
+Create a binary diff between two byte sequences.
+
+**Parameters:**
+
+* `old_data` (bytes): Original data.
+* `new_data` (bytes): Modified data.
+* `compression` (str or config object): Compression type as string (`"none"`, `"zlib"`, `"lzma"`, `"lzma2"`, `"zstd"`, `"bzip2"`, `"tamp"`) or a compression configuration object.
+* `validate` (bool): Test that the patch successfully converts `old_data` to `new_data`. This is a computationally inexpensive operation. Defaults to `True`.
+
+**Returns:** `bytes` - Binary diff data that can be used with `apply()` and `old_data` to generate `new_data`.
+
+---
+
+```python
+def apply(old_data, diff_data) -> bytes
+```
+
+Apply a binary patch to reconstruct new data.
+
+**Parameters:**
+
+* `old_data` (bytes): Original data.
+* `diff_data` (bytes): Patch data from `diff()`.
+
+**Returns:** `bytes` - Reconstructed data. The `new_data` that was passed to `diff()`.
+
+---
+
+```python
+def recompress(diff_data, compression=None) -> bytes
+```
+
+Recompress a diff with a different compression algorithm.
+
+**Parameters:**
+
+* `diff_data` (bytes): The diff data to recompress.
+* `compression` (str or config object, optional): Target compression type as string (`"none"`, `"zlib"`, `"lzma"`, `"lzma2"`, `"zstd"`, `"bzip2"`, `"tamp"`) or a compression configuration object. If None, removes compression.
+
+**Returns:** `bytes` - The recompressed diff data
+
+### Compression Configuration
+
+For advanced compression control, **hdiffpatch** provides configuration classes for each compression algorithm:
+
+#### ZStdConfig
+
+Fine-grained control over Zstandard compression:
+
+```python
+# Basic configuration
+config = hdiffpatch.ZStdConfig(level=15, window=20, workers=2)
+
+# Preset configurations
+config = hdiffpatch.ZStdConfig.fast()             # Optimized for speed
+config = hdiffpatch.ZStdConfig.balanced()         # Balanced speed/compression
+config = hdiffpatch.ZStdConfig.best_compression() # Maximum compression
+config = hdiffpatch.ZStdConfig.minimal_memory()   # Minimal memory usage
+
+# Use with diff
+diff = hdiffpatch.diff(old_data, new_data, compression=config)
+```
+
+**Parameters:**
+
+* `level` (1-22): Compression level, higher = better compression
+* `window` (10-27): Window size as log2, larger = better compression
+* `workers` (0-200): Number of threads, 0 = single-threaded
+
+#### ZlibConfig
+
+Fine-grained control over zlib compression:
+
+```python
+# Basic configuration
+config = hdiffpatch.ZlibConfig(
+    level=9,
+    memory_level=8,
+    window=15,
+    strategy=hdiffpatch.ZlibStrategy.DEFAULT
+)
+
+# Preset configurations
+config = hdiffpatch.ZlibConfig.fast()
+config = hdiffpatch.ZlibConfig.balanced()
+config = hdiffpatch.ZlibConfig.best_compression()
+config = hdiffpatch.ZlibConfig.minimal_memory()
+config = hdiffpatch.ZlibConfig.png_optimized()    # Optimized for PNG-like data
+```
+
+**Parameters:**
+
+* `level` (0-9): Compression level
+* `memory_level` (1-9): Memory usage level
+* `window` (9-15): Window size as power of 2
+* `strategy`: Compression strategy (`DEFAULT`, `FILTERED`, `HUFFMAN_ONLY`, `RLE`, `FIXED`)
+
+#### LzmaConfig and Lzma2Config
+
+Fine-grained control over LZMA compression:
+
+```python
+# LZMA configuration
+config = hdiffpatch.LzmaConfig(level=9, window=23, thread_num=1)
+
+# LZMA2 configuration (supports more threads)
+config = hdiffpatch.Lzma2Config(level=9, window=23, thread_num=4)
+
+# Preset configurations available for both
+config = hdiffpatch.LzmaConfig.fast()
+config = hdiffpatch.LzmaConfig.balanced()
+config = hdiffpatch.LzmaConfig.best_compression()
+config = hdiffpatch.LzmaConfig.minimal_memory()
+```
+
+**Parameters:**
+
+* `level` (0-9): Compression level
+* `window` (12-30): Window size as log2
+* `thread_num`: Number of threads (1-2 for LZMA, 1-64 for LZMA2)
+
+#### BZip2Config
+
+Fine-grained control over bzip2 compression:
+
+```python
+config = hdiffpatch.BZip2Config(level=9)
+
+# Preset configurations
+config = hdiffpatch.BZip2Config.fast()
+config = hdiffpatch.BZip2Config.balanced()
+config = hdiffpatch.BZip2Config.best_compression()
+config = hdiffpatch.BZip2Config.minimal_memory()
+```
+
+**Parameters:**
+
+* `level` (1-9): Compression level
+
+#### TampConfig
+
+Fine-grained control over [Tamp](https://github.com/BrianPugh/tamp) compression (embedded-friendly):
+
+```python
+config = hdiffpatch.TampConfig(window=10)
+
+# Preset configurations
+config = hdiffpatch.TampConfig.fast()
+config = hdiffpatch.TampConfig.balanced()
+config = hdiffpatch.TampConfig.best_compression()
+config = hdiffpatch.TampConfig.minimal_memory()
+```
+
+**Parameters:**
+
+* `window` (8-15): Window size as power of 2
+
+### Exceptions
+
+```python
+hdiffpatch.HDiffPatchError
+```
+
+## Compression Performance
+
+Different compression algorithms offer trade-offs between compression ratio and speed:
+
+* **`zlib`**: Good balance of speed and compression. Very common.
+* **`zstd`**: Fast compression with good ratios.
+* **`lzma`/`lzma2`**: Very high compression ratios, slower.
+* **`bzip2`**: Good compression, moderate speed
+* **`tamp`**: Embedded-friendly compression, minimal memory usage.
+
+### Basic Compression Comparison
+
+```python
+import hdiffpatch
+
+# Large repetitive data
+old_data = b"A" * 10000 + b"B" * 10000
+new_data = b"A" * 10000 + b"C" * 10000
+
+# Compare compression effectiveness
+for compression in ["none", "zlib", "zstd", "lzma", "bzip2", "tamp"]:
+    diff = hdiffpatch.diff(old_data, new_data, compression=compression)
+    print(f"{compression}: {len(diff)} bytes")
+```
+
+### Advanced Configuration Comparison
+
+```python
+import hdiffpatch
+
+# Compare different configuration approaches
+configs = {
+    "zstd_fast": hdiffpatch.ZStdConfig.fast(),
+    "zstd_best": hdiffpatch.ZStdConfig.best_compression(),
+    "zlib_balanced": hdiffpatch.ZlibConfig.balanced(),
+    "lzma2_custom": hdiffpatch.Lzma2Config(level=6, window=20, thread_num=4),
+}
+
+for name, config in configs.items():
+    diff = hdiffpatch.diff(old_data, new_data, compression=config)
+    print(f"{name}: {len(diff)} bytes")
+```
+
+### Real-World Example: MicroPython Firmware
+
+Here's a comprehensive comparison using actual MicroPython firmware files with a 12-bit window size (4096 bytes). This window size was chosen because it is typically a good trade-off between memory-usage and compression-performance for embedded targets.
+
+* [RPI_PICO-20241129-v1.24.1.uf2](https://micropython.org/resources/firmware/RPI_PICO-20241129-v1.24.1.uf2): 651 KB
+* [RPI_PICO-20250415-v1.25.0.uf2](https://micropython.org/resources/firmware/RPI_PICO-20250415-v1.25.0.uf2): 652 KB
+
+Since we're using compression for the diff, a natural question would be: "If I'm adding a decompression library to my target project, then how much smaller is the patch compared to just compressing the firmware?"
+To answer this question, we compare the size of the compressed patch to the compressed firmware.
+
+| Algorithm | Size (HDiffPatch) | Size (firmware) | Improvement |
+|-----------|-------------------|-----------------|-------------|
+| none      |          209.7 KB |        652.0 KB | 3.11x |
+| tamp      |          143.1 KB |        322.8 KB | 2.26x |
+| zstd      |          133.4 KB |        277.6 KB | 2.08x |
+| zlib      |          125.5 KB |        251.8 KB | 2.01x |
+| bzip2     |          128.6 KB |        246.2 KB | 1.91x |
+| lzma      |          116.9 KB |        222.7 KB | 1.91x |
+
+In this example, using **hdiffpatch** resulted in a ~3x smaller update when compared to a naive uncompressed firmware update, and ~2x smaller when comparing against an equivalently-compressed firmware update.
+
+To reproduce these results:
+
+```bash
+uv run python tools/micropython-binary-demo.py
+```

hdiffpatch-1.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+hdiffpatch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hdiffpatch/_base_config.py,sha256=WDY0Pl8bNRxFlA0AJtShmSkBr9nlUsQ-zKEAJjWBnrw,1657
+hdiffpatch/_bzip2_config.py,sha256=6fMohYu5L3_AaMlxjZFhByxL8-JNvoPDcKNj-vZN0L8,2113
+hdiffpatch/_c_extension.cp314-win_amd64.pyd,sha256=4aMSDAbITI84-bqdGrYmijj81zW2gp0rM2_VOB3LBYE,823296
+hdiffpatch/_c_extension.pyi,sha256=cM56jgsEgPJHP_uEiwT74e6Cy6CjJeDbB_YFr5MIDuc,3345
+hdiffpatch/_lzma_config.py,sha256=279rYp6DX_ZYq0TxZ3EsEbL2S2PwRuAJxFo9DFGT0oQ,6339
+hdiffpatch/_tamp_config.py,sha256=MvZXbL6L9qIqTblxLVC3yw5hmK6X0bHhl40xlFe_MPw,2063
+hdiffpatch/_zlib_config.py,sha256=-yBhc0mEj-j1_yAmDTWJ9mwa3fW1pimyFGyCcdRUyYY,5102
+hdiffpatch/_zstd_config.py,sha256=4GWN-8mAOct1JDB6QLe1fX-QTfIrSRuuRxxQgnLTeMs,3238
+hdiffpatch/__init__.py,sha256=PBIQLHNz30-Uae6XAJwW4wNkbTPq6isZDGioJWQH8qI,1630
+hdiffpatch-1.1.0.dist-info/DELVEWHEEL,sha256=-jbqjRgQ-KwUcgGkYKs8BA0UEzvyNeKhvm4hbULgVW0,409
+hdiffpatch-1.1.0.dist-info/METADATA,sha256=dmWChLJ8Y7R3r7xJVOxppUd1fb0d0iWIJF9F-dY5Wj8,12167
+hdiffpatch-1.1.0.dist-info/RECORD,,
+hdiffpatch-1.1.0.dist-info/scm_file_list.json,sha256=FJKC8I5Yw52AvZFZOtiJ3CR6Rzb5btBDNZyva_2Pzt4,153244
+hdiffpatch-1.1.0.dist-info/scm_version.json,sha256=zDDmWuNX4epXvAyPPaE5WyRBD7sNnt0Fq7Uq5xj-VhM,168
+hdiffpatch-1.1.0.dist-info/top_level.txt,sha256=IHwSCeRigLNb80MkH0f87HsMsvxktM_sC_H2Mg246tQ,11
+hdiffpatch-1.1.0.dist-info/WHEEL,sha256=pIUzES5vCYHKBR6AfxXxDFyqjZ9ckCheusePfq1FYSo,101
+hdiffpatch-1.1.0.dist-info/licenses/LICENSE,sha256=NlaN0UJZDwQsLaQ4kMTmn_Q4BogQGPxRbjlWM0D1SSI,11558
+hdiffpatch.libs/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056

hdiffpatch-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64
+