hdiffpatch 1.1.0__cp314-cp314-win_amd64.whl

hdiffpatch/__init__.py

@@ -0,0 +1,80 @@
+# Don't manually change, let setuptools-scm handle it.
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'hdiffpatch.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch
+
+__version__ = "0.0.0"
+
+__all__ = [
+    # Types and constants
+    "COMPRESSION_BZIP2",
+    "COMPRESSION_LZMA",
+    "COMPRESSION_LZMA2",
+    "COMPRESSION_NONE",
+    "COMPRESSION_TAMP",
+    "COMPRESSION_ZLIB",
+    "COMPRESSION_ZSTD",
+    "CompressionType",
+    # Exceptions
+    "HDiffPatchError",
+    # Core functions
+    "diff",
+    "apply",
+    "recompress",
+    # Configuration classes
+    "BaseConfig",
+    "BZip2Config",
+    "ZlibConfig",
+    "ZlibStrategy",
+    "LzmaConfig",
+    "Lzma2Config",
+    "TampConfig",
+    "ZStdConfig",
+]
+
+from ._base_config import (
+    BaseConfig,
+)
+from ._bzip2_config import (
+    BZip2Config,
+)
+from ._c_extension import (
+    # Types and constants
+    COMPRESSION_BZIP2,
+    COMPRESSION_LZMA,
+    COMPRESSION_LZMA2,
+    COMPRESSION_NONE,
+    COMPRESSION_TAMP,
+    COMPRESSION_ZLIB,
+    COMPRESSION_ZSTD,
+    CompressionType,
+    # Exceptions
+    HDiffPatchError,
+    # Core functions
+    apply,
+    diff,
+    recompress,
+)
+from ._lzma_config import (
+    Lzma2Config,
+    LzmaConfig,
+)
+from ._tamp_config import (
+    TampConfig,
+)
+from ._zlib_config import (
+    ZlibConfig,
+    ZlibStrategy,
+)
+from ._zstd_config import (
+    ZStdConfig,
+)

hdiffpatch/_base_config.py

@@ -0,0 +1,56 @@
+"""Base configuration class for compression configs."""
+
+import attrs
+
+
+@attrs.frozen
+class BaseConfig:
+    """Base class for all compression configuration classes.
+
+    This class provides common functionality for all compression configurations,
+    including standardized classmethods for creating common configuration presets.
+    """
+
+    @classmethod
+    def fast(cls):
+        """Create a config optimized for speed.
+
+        Returns
+        -------
+        BaseConfig
+            Configuration optimized for speed
+        """
+        raise NotImplementedError(f"{cls.__name__} does not implement fast() classmethod")
+
+    @classmethod
+    def balanced(cls):
+        """Create a config with balanced speed/compression.
+
+        Returns
+        -------
+        BaseConfig
+            Configuration with balanced speed/compression tradeoff
+        """
+        raise NotImplementedError(f"{cls.__name__} does not implement balanced() classmethod")
+
+    @classmethod
+    def best_compression(cls):
+        """Create a config optimized for best compression.
+
+        Returns
+        -------
+        BaseConfig
+            Configuration optimized for best compression
+        """
+        raise NotImplementedError(f"{cls.__name__} does not implement best_compression() classmethod")
+
+    @classmethod
+    def minimal_memory(cls):
+        """Create a config with minimal memory usage.
+
+        Returns
+        -------
+        BaseConfig
+            Configuration with minimal memory usage
+        """
+        raise NotImplementedError(f"{cls.__name__} does not implement minimal_memory() classmethod")

hdiffpatch/_bzip2_config.py

@@ -0,0 +1,84 @@
+"""BZip2Config class for configuring bzip2 compression parameters."""
+
+import attrs
+
+from ._base_config import BaseConfig
+
+
+@attrs.frozen
+class BZip2Config(BaseConfig):
+    """Configuration for bzip2 compression parameters.
+
+    This class allows control over bzip2 compression behavior via the
+    compression level, which trades speed for compression ratio and
+    memory usage.
+
+    Parameters
+    ----------
+    level : int, default=9
+        Compression level (1-9). Higher values give better
+        compression but are slower. 1 = fastest, 9 = best compression.
+
+    Examples
+    --------
+    Fast compression
+
+    >>> config = BZip2Config(level=1)
+
+    Best compression
+
+    >>> config = BZip2Config(level=9)
+    """
+
+    level: int = attrs.field(
+        default=9,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(1),
+            attrs.validators.le(9),
+        ),
+    )
+
+    @classmethod
+    def fast(cls) -> "BZip2Config":
+        """Create a BZip2Config optimized for speed.
+
+        Returns
+        -------
+        BZip2Config
+            Configuration optimized for speed
+        """
+        return cls(level=1)
+
+    @classmethod
+    def balanced(cls) -> "BZip2Config":
+        """Create a BZip2Config with balanced speed/compression.
+
+        Returns
+        -------
+        BZip2Config
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(level=6)
+
+    @classmethod
+    def best_compression(cls) -> "BZip2Config":
+        """Create a BZip2Config optimized for best compression.
+
+        Returns
+        -------
+        BZip2Config
+            Configuration optimized for best compression
+        """
+        return cls(level=9)
+
+    @classmethod
+    def minimal_memory(cls) -> "BZip2Config":
+        """Create a BZip2Config with minimal memory usage.
+
+        Returns
+        -------
+        BZip2Config
+            Configuration with minimal memory usage
+        """
+        return cls(level=1)

hdiffpatch/_c_extension.pyi

@@ -0,0 +1,121 @@
+from typing import TYPE_CHECKING, Literal, Union
+
+if TYPE_CHECKING:
+    from ._base_config import BaseConfig
+
+CompressionType = Literal["none", "zlib", "lzma", "lzma2", "zstd", "bzip2", "tamp"]
+
+# Constants for convenience
+COMPRESSION_NONE: CompressionType = "none"
+COMPRESSION_ZLIB: CompressionType = "zlib"
+COMPRESSION_LZMA: CompressionType = "lzma"
+COMPRESSION_LZMA2: CompressionType = "lzma2"
+COMPRESSION_ZSTD: CompressionType = "zstd"
+COMPRESSION_BZIP2: CompressionType = "bzip2"
+COMPRESSION_TAMP: CompressionType = "tamp"
+
+class HDiffPatchError(Exception):
+    """Base exception for HDiffPatch operations."""
+
+    ...
+
+def diff(
+    old_data: bytes,
+    new_data: bytes,
+    compression: Union[CompressionType, BaseConfig, None] = None,
+    *,
+    validate: bool = True,
+) -> bytes:
+    """Create a binary diff between old and new data using HDiffPatch.
+
+    Parameters
+    ----------
+    old_data : bytes
+        The original data
+    new_data : bytes
+        The new data to diff against
+    compression : CompressionType, BaseConfig, or None, default=None
+        Compression algorithm to use
+    validate : bool, default=True
+        If True, validates that applying the diff to old_data produces new_data
+
+    Returns
+    -------
+    bytes
+        The diff data as bytes
+
+    Raises
+    ------
+    TypeError
+        If old_data or new_data are not bytes
+    HDiffPatchError
+        If diff creation fails or roundtrip validation fails
+    """
+    ...
+
+def apply(
+    old_data: bytes,
+    diff_data: bytes,
+) -> bytes:
+    """Apply a patch to old data to produce new data using HDiffPatch.
+
+    The compression type is automatically detected from the diff data header.
+
+    Parameters
+    ----------
+    old_data : bytes
+        The original data
+    diff_data : bytes
+        The diff/patch data
+
+    Returns
+    -------
+    bytes
+        The patched data as bytes
+
+    Raises
+    ------
+    TypeError
+        If old_data or diff_data are not bytes
+    HDiffPatchError
+        If patch application fails
+    MemoryError
+        If memory allocation fails
+    """
+    ...
+
+def recompress(
+    diff_data: bytes,
+    compression: Union[CompressionType, BaseConfig, None] = None,
+) -> bytes:
+    """Recompress a diff with a different compression algorithm.
+
+    This function can recompress diffs in HDiffPatch's compressed diff format, which includes
+    diffs created by hdiffz (both compressed and uncompressed). The input format is automatically
+    detected and the diff is recompressed with the specified compression algorithm.
+
+    Supports both single-compressed and regular compressed diff formats. Works with diffs
+    created by hdiffz tool and the hdiffpatch.diff() function when explicit compression is used.
+
+    Parameters
+    ----------
+    diff_data : bytes
+        The diff data to recompress
+    compression : CompressionType, BaseConfig, or None, default=None
+        Target compression algorithm to use
+
+    Returns
+    -------
+    bytes
+        The recompressed diff data
+
+    Raises
+    ------
+    TypeError
+        If diff_data is not bytes
+    HDiffPatchError
+        If recompression fails or input format is unsupported
+    ValueError
+        If compression type is invalid
+    """
+    ...

hdiffpatch/_lzma_config.py

@@ -0,0 +1,213 @@
+"""LzmaConfig and Lzma2Config classes for configuring LZMA compression parameters."""
+
+import attrs
+
+from ._base_config import BaseConfig
+
+
+@attrs.frozen
+class LzmaConfig(BaseConfig):
+    """Configuration for LZMA compression parameters.
+
+    This class allows fine-grained control over LZMA compression behavior,
+    including compression level, dictionary size, and thread usage.
+
+    Parameters
+    ----------
+    level : int, default=9
+        Compression level (0-9). Higher values give better
+        compression but are slower. 0 = no compression, 9 = best compression.
+    window : int, default=23
+        Window size as log2. Must be between 12 and 30.
+        Larger windows give better compression but use more memory.
+        (23 = 8MB window)
+    thread_num : int, default=1
+        Number of threads (1-2). LZMA supports up to 2 threads.
+
+    Examples
+    --------
+    Fast compression with minimal memory usage (4KB window)
+
+    >>> config = LzmaConfig(level=1, window=12, thread_num=1)
+
+    Best compression for large files (32MB window)
+
+    >>> config = LzmaConfig(level=9, window=25, thread_num=2)
+
+    Balanced compression (8MB window)
+
+    >>> config = LzmaConfig(level=6, window=23, thread_num=1)
+    """
+
+    level: int = attrs.field(
+        default=9,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(0),
+            attrs.validators.le(9),
+        ),
+    )
+    window: int = attrs.field(
+        default=23,  # 8MB (2^23)
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(12),
+            attrs.validators.le(30),
+        ),
+    )
+    thread_num: int = attrs.field(
+        default=1,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(1),
+            attrs.validators.le(2),
+        ),
+    )
+
+    @classmethod
+    def fast(cls) -> "LzmaConfig":
+        """Create an LzmaConfig optimized for speed.
+
+        Returns
+        -------
+        LzmaConfig
+            Configuration optimized for speed
+        """
+        return cls(level=1, window=12, thread_num=1)
+
+    @classmethod
+    def balanced(cls) -> "LzmaConfig":
+        """Create an LzmaConfig with balanced speed/compression.
+
+        Returns
+        -------
+        LzmaConfig
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(level=6, window=23, thread_num=1)
+
+    @classmethod
+    def best_compression(cls) -> "LzmaConfig":
+        """Create an LzmaConfig optimized for best compression.
+
+        Returns
+        -------
+        LzmaConfig
+            Configuration optimized for best compression
+        """
+        return cls(level=9, window=25, thread_num=2)
+
+    @classmethod
+    def minimal_memory(cls) -> "LzmaConfig":
+        """Create an LzmaConfig with minimal memory usage.
+
+        Returns
+        -------
+        LzmaConfig
+            Configuration with minimal memory usage
+        """
+        return cls(level=6, window=12, thread_num=1)
+
+
+@attrs.frozen
+class Lzma2Config(BaseConfig):
+    """Configuration for LZMA2 compression parameters.
+
+    This class allows fine-grained control over LZMA2 compression behavior,
+    including compression level, dictionary size, and thread usage.
+
+    Parameters
+    ----------
+    level : int, default=9
+        Compression level (0-9). Higher values give better
+        compression but are slower. 0 = no compression, 9 = best compression.
+    window : int, default=23
+        Window size as log2. Must be between 12 and 30.
+        Larger windows give better compression but use more memory.
+        (23 = 8MB window)
+    thread_num : int, default=1
+        Number of threads (1-64). LZMA2 supports up to 64 threads.
+
+    Examples
+    --------
+    Fast compression with minimal memory usage (4KB window)
+
+    >>> config = Lzma2Config(level=1, window=12, thread_num=1)
+
+    Best compression for large files with multiple threads (32MB window)
+
+    >>> config = Lzma2Config(level=9, window=25, thread_num=8)
+
+    Balanced compression with moderate threading (8MB window)
+
+    >>> config = Lzma2Config(level=6, window=23, thread_num=4)
+    """
+
+    level: int = attrs.field(
+        default=9,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(0),
+            attrs.validators.le(9),
+        ),
+    )
+    window: int = attrs.field(
+        default=23,  # 8MB (2^23)
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(12),
+            attrs.validators.le(30),
+        ),
+    )
+    thread_num: int = attrs.field(
+        default=1,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(1),
+            attrs.validators.le(64),
+        ),
+    )
+
+    @classmethod
+    def fast(cls) -> "Lzma2Config":
+        """Create an Lzma2Config optimized for speed.
+
+        Returns
+        -------
+        Lzma2Config
+            Configuration optimized for speed
+        """
+        return cls(level=1, window=12, thread_num=1)
+
+    @classmethod
+    def balanced(cls) -> "Lzma2Config":
+        """Create an Lzma2Config with balanced speed/compression.
+
+        Returns
+        -------
+        Lzma2Config
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(level=6, window=23, thread_num=4)
+
+    @classmethod
+    def best_compression(cls) -> "Lzma2Config":
+        """Create an Lzma2Config optimized for best compression.
+
+        Returns
+        -------
+        Lzma2Config
+            Configuration optimized for best compression
+        """
+        return cls(level=9, window=25, thread_num=8)
+
+    @classmethod
+    def minimal_memory(cls) -> "Lzma2Config":
+        """Create an Lzma2Config with minimal memory usage.
+
+        Returns
+        -------
+        Lzma2Config
+            Configuration with minimal memory usage
+        """
+        return cls(level=6, window=12, thread_num=1)

hdiffpatch/_tamp_config.py

@@ -0,0 +1,83 @@
+"""TampConfig class for configuring tamp compression parameters."""
+
+import attrs
+
+from ._base_config import BaseConfig
+
+
+@attrs.frozen
+class TampConfig(BaseConfig):
+    """Configuration for tamp compression parameters.
+
+    This class allows control over tamp compression behavior,
+    including window size and custom dictionary support.
+
+    Parameters
+    ----------
+    window : int, default=10
+        Window size as power of 2 (8-15). Larger windows give
+        better compression but use more memory. (1KB window)
+
+    Examples
+    --------
+    Default configuration
+
+    >>> config = TampConfig()
+
+    Custom window size
+
+    >>> config = TampConfig(window=12)
+    """
+
+    window: int = attrs.field(
+        default=10,
+        validator=attrs.validators.and_(
+            attrs.validators.instance_of(int),
+            attrs.validators.ge(8),
+            attrs.validators.le(15),
+        ),
+    )
+
+    @classmethod
+    def fast(cls) -> "TampConfig":
+        """Create a TampConfig optimized for speed.
+
+        Returns
+        -------
+        TampConfig
+            Configuration optimized for speed
+        """
+        return cls(window=8)
+
+    @classmethod
+    def balanced(cls) -> "TampConfig":
+        """Create a TampConfig with balanced speed/compression.
+
+        Returns
+        -------
+        TampConfig
+            Configuration with balanced speed/compression tradeoff
+        """
+        return cls(window=10)
+
+    @classmethod
+    def best_compression(cls) -> "TampConfig":
+        """Create a TampConfig optimized for best compression.
+
+        Returns
+        -------
+        TampConfig
+            Configuration optimized for best compression
+        """
+        return cls(window=15)
+
+    @classmethod
+    def minimal_memory(cls) -> "TampConfig":
+        """Create a TampConfig with minimal memory usage.
+
+        Returns
+        -------
+        TampConfig
+            Configuration with minimal memory usage
+        """
+        return cls(window=8)