PyPI - zxtd - Versions diffs - 0.1.0__tar.gz - Mend

zxtd 0.1.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

zxtd-0.1.0/Cargo.lock ADDED Viewed

@@ -0,0 +1,334 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+[[package]]
+name = "cc"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f360145194ee8e21db5ee7f3fcd4fe52210864c75c985dae33218202c8bbe040"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+]
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+[[package]]
+name = "jobserver"
+version = "0.1.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
+dependencies = [
+ "getrandom",
+ "libc",
+]
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+[[package]]
+name = "pkg-config"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+[[package]]
+name = "pyo3"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+[[package]]
+name = "pyo3-build-config"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+[[package]]
+name = "pyo3-ffi"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+[[package]]
+name = "pyo3-macros"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 2.0.119",
+]
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn 2.0.119",
+]
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+[[package]]
+name = "thiserror"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
+dependencies = [
+ "thiserror-impl",
+]
+[[package]]
+name = "thiserror-impl"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+[[package]]
+name = "tokio"
+version = "1.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
+dependencies = [
+ "bytes",
+ "pin-project-lite",
+ "tokio-macros",
+]
+[[package]]
+name = "tokio-macros"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+[[package]]
+name = "zstd-safe"
+version = "7.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882"
+dependencies = [
+ "zstd-sys",
+]
+[[package]]
+name = "zstd-sys"
+version = "2.1.0+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+[[package]]
+name = "zxtd"
+version = "0.1.0"
+dependencies = [
+ "bytes",
+ "pyo3",
+ "thiserror",
+ "tokio",
+ "zstd",
+]

zxtd-0.1.0/Cargo.toml ADDED Viewed

@@ -0,0 +1,21 @@
+[package]
+name = "zxtd"
+version = "0.1.0"
+edition = "2024"
+readme = "README.md"
+[lib]
+name = "zxtd"
+crate-type = ["cdylib", "rlib"]
+[dependencies]
+zstd = { version = "0.13", features = ["zstdmt"] }
+thiserror = "2.0"
+tokio = { version = "1.40", features = ["io-util", "rt-multi-thread", "macros"], optional = true }
+bytes = { version = "1.6", optional = true }
+pyo3 = { version = "0.24", features = ["extension-module"], optional = true }
+[features]
+default = []
+async = ["tokio", "bytes"]
+python = ["pyo3"]

zxtd-0.1.0/PKG-INFO ADDED Viewed

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: zxtd
+Version: 0.1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Rust
+Classifier: Topic :: System :: Archiving :: Compression
+Summary: High-performance Zstandard compression/decompression with dictionary support - zxtd
+Author: Quadrium
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+# zxtd
+High-performance Zstandard compression/decompression library with dictionary support, multi-threading, and Python bindings.
+Author: **Quadrium**
+## Features
+- **Fast compression/decompression** using Facebook's Zstandard (zstd) library
+- **Dictionary support** for better compression ratios on small data
+- **Multi-threaded compression** for improved performance on large data
+- **Streaming API** for memory-efficient processing of large files
+- **Frame inspection** to detect dictionary IDs and content sizes
+- **Checksum verification** for data integrity
+- **Python bindings** via PyO3/maturin
+- **Async support** (optional feature)
+## Installation
+```bash
+pip install zxtd
+```
+## Python Usage
+```python
+import zxtd
+# Basic compression/decompression
+data = b"Hello, Zstandard! " * 100
+compressed = zxtd.compress(data, 3)  # level 1-22
+decompressed = zxtd.decompress(compressed)
+assert decompressed == data
+# Dictionary compression (better for small, similar data)
+dict_data = b"common prefix that repeats often "
+dictionary = zxtd.Dictionary.from_bytes(dict_data)
+original = b"common prefix that repeats often - unique part"
+compressed = zxtd.compress_with_dict(original, 3, dictionary)
+decompressed = zxtd.decompress_with_dict(compressed, dictionary)
+# Custom compression parameters
+params = zxtd.CompressionParams(6)
+params.with_threads(4)           # Use 4 threads
+params.with_checksum(True)       # Enable checksum
+compressed = zxtd.compress_with_params(data, params)
+# Frame inspection
+info = zxtd.frame_info(compressed)
+print(f"Magic: 0x{info.magic:x}, Dict ID: {info.dict_id}")
+# Detect dictionary ID from frame
+dict_id = zxtd.Dictionary.detect_dict_id(compressed)
+# Compression levels
+levels = zxtd.compression_levels()
+# {'FASTEST': 1, 'FAST': 3, 'DEFAULT': 3, 'BETTER': 6, 'BEST': 9, 'ULTRA': 22}
+# Verify checksum
+decompressed = zxtd.decompress_verify(compressed)
+```
+## Rust Usage
+Add to `Cargo.toml`:
+```toml
+zxtd = { path = "../zstd-decompress", features = ["async"] }
+```
+```rust
+use zxtd::{compress, decompress, CompressionParams, Dictionary};
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let data = b"Hello, Zstandard!";
+    // Basic usage
+    let compressed = compress(data, 3)?;
+    let decompressed = decompress(&compressed)?;
+    assert_eq!(data, &decompressed[..]);
+    // With dictionary
+    let dict = Dictionary::new(b"common prefix ".to_vec())?;
+    let compressed = compress_with_dict(data, 3, &dict)?;
+    let decompressed = decompress_with_dict(&compressed, &dict)?;
+    // Custom params with multi-threading
+    let params = CompressionParams::new(6).with_threads(4);
+    let compressed = compress_with_params(data, &params, None)?;
+    // Streaming
+    let mut decompressor = StreamingDecompressor::new(compressed)?;
+    let mut buf = [0u8; 1024];
+    while let Ok(n) = decompressor.read(&mut buf) {
+        if n == 0 { break; }
+        // process buf[..n]
+    }
+    Ok(())
+}
+```
+## Performance
+- Multi-threaded compression scales linearly with cores
+- Dictionary compression can achieve 2-5x better ratios on small similar data
+- Streaming API uses constant memory regardless of input size
+- Zero-copy decompression where possible
+## License
+MIT

zxtd-0.1.0/README.md ADDED Viewed

@@ -0,0 +1,112 @@
+# zxtd
+High-performance Zstandard compression/decompression library with dictionary support, multi-threading, and Python bindings.
+Author: **Quadrium**
+## Features
+- **Fast compression/decompression** using Facebook's Zstandard (zstd) library
+- **Dictionary support** for better compression ratios on small data
+- **Multi-threaded compression** for improved performance on large data
+- **Streaming API** for memory-efficient processing of large files
+- **Frame inspection** to detect dictionary IDs and content sizes
+- **Checksum verification** for data integrity
+- **Python bindings** via PyO3/maturin
+- **Async support** (optional feature)
+## Installation
+```bash
+pip install zxtd
+```
+## Python Usage
+```python
+import zxtd
+# Basic compression/decompression
+data = b"Hello, Zstandard! " * 100
+compressed = zxtd.compress(data, 3)  # level 1-22
+decompressed = zxtd.decompress(compressed)
+assert decompressed == data
+# Dictionary compression (better for small, similar data)
+dict_data = b"common prefix that repeats often "
+dictionary = zxtd.Dictionary.from_bytes(dict_data)
+original = b"common prefix that repeats often - unique part"
+compressed = zxtd.compress_with_dict(original, 3, dictionary)
+decompressed = zxtd.decompress_with_dict(compressed, dictionary)
+# Custom compression parameters
+params = zxtd.CompressionParams(6)
+params.with_threads(4)           # Use 4 threads
+params.with_checksum(True)       # Enable checksum
+compressed = zxtd.compress_with_params(data, params)
+# Frame inspection
+info = zxtd.frame_info(compressed)
+print(f"Magic: 0x{info.magic:x}, Dict ID: {info.dict_id}")
+# Detect dictionary ID from frame
+dict_id = zxtd.Dictionary.detect_dict_id(compressed)
+# Compression levels
+levels = zxtd.compression_levels()
+# {'FASTEST': 1, 'FAST': 3, 'DEFAULT': 3, 'BETTER': 6, 'BEST': 9, 'ULTRA': 22}
+# Verify checksum
+decompressed = zxtd.decompress_verify(compressed)
+```
+## Rust Usage
+Add to `Cargo.toml`:
+```toml
+zxtd = { path = "../zstd-decompress", features = ["async"] }
+```
+```rust
+use zxtd::{compress, decompress, CompressionParams, Dictionary};
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let data = b"Hello, Zstandard!";
+    // Basic usage
+    let compressed = compress(data, 3)?;
+    let decompressed = decompress(&compressed)?;
+    assert_eq!(data, &decompressed[..]);
+    // With dictionary
+    let dict = Dictionary::new(b"common prefix ".to_vec())?;
+    let compressed = compress_with_dict(data, 3, &dict)?;
+    let decompressed = decompress_with_dict(&compressed, &dict)?;
+    // Custom params with multi-threading
+    let params = CompressionParams::new(6).with_threads(4);
+    let compressed = compress_with_params(data, &params, None)?;
+    // Streaming
+    let mut decompressor = StreamingDecompressor::new(compressed)?;
+    let mut buf = [0u8; 1024];
+    while let Ok(n) = decompressor.read(&mut buf) {
+        if n == 0 { break; }
+        // process buf[..n]
+    }
+    Ok(())
+}
+```
+## Performance
+- Multi-threaded compression scales linearly with cores
+- Dictionary compression can achieve 2-5x better ratios on small similar data
+- Streaming API uses constant memory regardless of input size
+- Zero-copy decompression where possible
+## License
+MIT

zxtd-0.1.0/pyproject.toml ADDED Viewed

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["maturin>=1.8,<2.0"]
+build-backend = "maturin"
+[project]
+name = "zxtd"
+version = "0.1.0"
+description = "High-performance Zstandard compression/decompression with dictionary support - zxtd"
+readme = "README.md"
+authors = [{name = "Quadrium"}]
+license = {text = "MIT"}
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Rust",
+    "Topic :: System :: Archiving :: Compression",
+]
+[tool.maturin]
+features = ["python"]
+compatibility = "off"  # Disable abi3 for latest Python support
+[tool.maturin.scripts]
+test = "python -m pytest tests/"

zxtd-0.1.0/src/lib.rs ADDED Viewed

@@ -0,0 +1,524 @@
+use std::io::{Read, Write};
+use zstd::stream::{decode_all, Decoder, Encoder};
+#[derive(Debug, thiserror::Error)]
+pub enum ZstdError {
+    #[error("Zstd error: {0}")]
+    Zstd(String),
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Dictionary error: {0}")]
+    Dictionary(String),
+    #[error("Invalid parameter: {0}")]
+    InvalidParam(String),
+    #[error("Checksum mismatch")]
+    ChecksumMismatch,
+    #[error("Async feature not enabled")]
+    AsyncNotEnabled,
+}
+pub type Result<T> = std::result::Result<T, ZstdError>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompressionLevel {
+    Fastest,
+    Fast,
+    Default,
+    Better,
+    Best,
+    Ultra,
+}
+impl From<CompressionLevel> for i32 {
+    fn from(level: CompressionLevel) -> i32 {
+        match level {
+            CompressionLevel::Fastest => 1,
+            CompressionLevel::Fast => 3,
+            CompressionLevel::Default => 3,
+            CompressionLevel::Better => 6,
+            CompressionLevel::Best => 9,
+            CompressionLevel::Ultra => 22,
+        }
+    }
+}
+impl Default for CompressionLevel {
+    fn default() -> Self {
+        CompressionLevel::Default
+    }
+}
+#[derive(Debug, Clone)]
+pub struct CompressionParams {
+    pub level: i32,
+    pub threads: u32,
+    pub checksum: bool,
+    pub content_size: bool,
+    pub dict_id: bool,
+}
+impl Default for CompressionParams {
+    fn default() -> Self {
+        Self {
+            level: 3,
+            threads: 0,
+            checksum: true,
+            content_size: true,
+            dict_id: true,
+        }
+    }
+}
+impl CompressionParams {
+    pub fn new(level: impl Into<i32>) -> Self {
+        Self { level: level.into(), ..Default::default() }
+    }
+    pub fn with_threads(mut self, threads: u32) -> Self {
+        self.threads = threads;
+        self
+    }
+    pub fn with_checksum(mut self, enable: bool) -> Self {
+        self.checksum = enable;
+        self
+    }
+    pub fn with_content_size(mut self, enable: bool) -> Self {
+        self.content_size = enable;
+        self
+    }
+    pub fn with_dict_id(mut self, enable: bool) -> Self {
+        self.dict_id = enable;
+        self
+    }
+}
+#[derive(Debug, Clone)]
+pub struct Dictionary {
+    data: Vec<u8>,
+}
+impl Dictionary {
+    pub fn new(data: Vec<u8>) -> Result<Self> {
+        if data.len() < 8 {
+            return Err(ZstdError::Dictionary("Dictionary too small (min 8 bytes)".into()));
+        }
+        Ok(Self { data })
+    }
+    pub fn from_bytes(data: &[u8]) -> Result<Self> {
+        Self::new(data.to_vec())
+    }
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.data
+    }
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+    pub fn detect_dict_id_from_frame(data: &[u8]) -> Option<u32> {
+        if data.len() < 8 { return None; }
+        let magic = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
+        match magic {
+            0x28B52FED => {
+                if data.len() < 8 { return None; }
+                Some(u32::from_le_bytes([data[4], data[5], data[6], data[7]]))
+            }
+            0xFD2FB528 => {
+                if data.len() < 12 { return None; }
+                Some(u32::from_le_bytes([data[8], data[9], data[10], data[11]]))
+            }
+            _ => None,
+        }
+    }
+}
+fn build_encoder<'a, W: Write>(writer: W, params: &CompressionParams, dict: Option<&Dictionary>) -> Result<Encoder<'a, W>> {
+    let mut encoder = if let Some(d) = dict {
+        Encoder::with_dictionary(writer, params.level, d.as_bytes())
+    } else {
+        Encoder::new(writer, params.level)
+    }.map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    if params.threads > 0 {
+        encoder.multithread(params.threads).map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    }
+    encoder.include_checksum(params.checksum);
+    encoder.include_contentsize(params.content_size);
+    encoder.include_dictid(params.dict_id);
+    Ok(encoder)
+}
+pub fn decompress(data: &[u8]) -> Result<Vec<u8>> {
+    decode_all(data).map_err(|e| ZstdError::Zstd(e.to_string()))
+}
+pub fn decompress_with_dict(data: &[u8], dict: &Dictionary) -> Result<Vec<u8>> {
+    let mut decoder = Decoder::with_dictionary(data, dict.as_bytes())
+        .map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    let mut out = Vec::new();
+    std::io::copy(&mut decoder, &mut out)?;
+    Ok(out)
+}
+pub fn decompress_to_writer(data: &[u8], writer: &mut impl Write) -> Result<()> {
+    let mut decoder = Decoder::new(data).map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    std::io::copy(&mut decoder, writer)?;
+    Ok(())
+}
+pub fn decompress_to_writer_with_dict(data: &[u8], writer: &mut impl Write, dict: &Dictionary) -> Result<()> {
+    let mut decoder = Decoder::with_dictionary(data, dict.as_bytes())
+        .map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    std::io::copy(&mut decoder, writer)?;
+    Ok(())
+}
+pub fn decompress_verify_checksum(data: &[u8]) -> Result<Vec<u8>> {
+    let mut decoder = Decoder::new(data).map_err(|e| ZstdError::Zstd(e.to_string()))?;
+    let mut out = Vec::new();
+    std::io::copy(&mut decoder, &mut out)?;
+    Ok(out)
+}
+pub struct StreamingDecompressor {
+    decoder: Decoder<'static, std::io::BufReader<std::io::Cursor<Vec<u8>>>>,
+}
+impl StreamingDecompressor {
+    pub fn new(data: Vec<u8>) -> Result<Self> {
+        let cursor = std::io::Cursor::new(data);
+        let decoder = Decoder::new(cursor).map_err(|e| ZstdError::Zstd(e.to_string()))?;
+        Ok(Self { decoder })
+    }
+    pub fn new_with_dict(data: Vec<u8>, dict: &Dictionary) -> Result<Self> {
+        let cursor = std::io::Cursor::new(data);
+        let reader = std::io::BufReader::new(cursor);
+        let decoder = Decoder::with_dictionary(reader, dict.as_bytes())
+            .map_err(|e| ZstdError::Zstd(e.to_string()))?;
+        Ok(Self { decoder })
+    }
+    pub fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        Ok(self.decoder.read(buf)?)
+    }
+    pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
+        Ok(self.decoder.read_exact(buf)?)
+    }
+}
+pub fn compress(data: &[u8], level: impl Into<i32>) -> Result<Vec<u8>> {
+    let params = CompressionParams::new(level);
+    compress_with_params(data, &params, None)
+}
+pub fn compress_with_dict(data: &[u8], level: impl Into<i32>, dict: &Dictionary) -> Result<Vec<u8>> {
+    let params = CompressionParams::new(level);
+    compress_with_params(data, &params, Some(dict))
+}
+pub fn compress_with_params(data: &[u8], params: &CompressionParams, dict: Option<&Dictionary>) -> Result<Vec<u8>> {
+    let mut out = Vec::with_capacity(data.len() / 2);
+    let mut encoder = build_encoder(&mut out, params, dict)?;
+    encoder.write_all(data)?;
+    encoder.finish()?;
+    Ok(out)
+}
+pub fn compress_to_writer(data: &[u8], writer: &mut impl Write, level: impl Into<i32>) -> Result<()> {
+    let params = CompressionParams::new(level);
+    compress_to_writer_with_params(data, writer, &params, None)
+}
+pub fn compress_to_writer_with_dict(data: &[u8], writer: &mut impl Write, level: impl Into<i32>, dict: &Dictionary) -> Result<()> {
+    let params = CompressionParams::new(level);
+    compress_to_writer_with_params(data, writer, &params, Some(dict))
+}
+pub fn compress_to_writer_with_params(data: &[u8], writer: &mut impl Write, params: &CompressionParams, dict: Option<&Dictionary>) -> Result<()> {
+    let mut encoder = build_encoder(writer, params, dict)?;
+    encoder.write_all(data)?;
+    encoder.finish()?;
+    Ok(())
+}
+pub struct StreamingCompressor<'a, W: Write> {
+    encoder: Encoder<'a, W>,
+}
+impl<'a, W: Write> StreamingCompressor<'a, W> {
+    pub fn new(writer: W, level: impl Into<i32>) -> Result<Self> {
+        let params = CompressionParams::new(level);
+        let encoder = build_encoder(writer, &params, None)?;
+        Ok(Self { encoder })
+    }
+    pub fn new_with_params(writer: W, params: &CompressionParams) -> Result<Self> {
+        let encoder = build_encoder(writer, params, None)?;
+        Ok(Self { encoder })
+    }
+    pub fn new_with_dict(writer: W, level: impl Into<i32>, dict: &Dictionary) -> Result<Self> {
+        let params = CompressionParams::new(level);
+        let encoder = build_encoder(writer, &params, Some(dict))?;
+        Ok(Self { encoder })
+    }
+    pub fn write(&mut self, buf: &[u8]) -> Result<usize> {
+        Ok(self.encoder.write(buf)?)
+    }
+    pub fn flush(&mut self) -> Result<()> {
+        Ok(self.encoder.flush()?)
+    }
+    pub fn finish(self) -> Result<W> {
+        self.encoder.finish().map_err(|e| ZstdError::Zstd(e.to_string()))
+    }
+    pub fn get_ref(&self) -> &W {
+        self.encoder.get_ref()
+    }
+    pub fn get_mut(&mut self) -> &mut W {
+        self.encoder.get_mut()
+    }
+}
+#[cfg(feature = "async")]
+pub mod async_api {
+    use super::*;
+    use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+    pub struct AsyncStreamingDecompressor<R: AsyncRead + Unpin> {
+        reader: R,
+        buffer: Vec<u8>,
+        eof: bool,
+    }
+    impl<R: AsyncRead + Unpin> AsyncStreamingDecompressor<R> {
+        pub fn new(reader: R) -> Self {
+            Self { reader, buffer: Vec::with_capacity(64 * 1024), eof: false }
+        }
+        pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+            if self.eof && self.buffer.is_empty() {
+                return Ok(0);
+            }
+            while self.buffer.len() < buf.len() && !self.eof {
+                let mut chunk = vec![0u8; 64 * 1024];
+                let n = self.reader.read(&mut chunk).await.map_err(ZstdError::Io)?;
+                if n == 0 {
+                    self.eof = true;
+                    break;
+                }
+                self.buffer.extend_from_slice(&chunk[..n]);
+            }
+            let to_copy = std::cmp::min(buf.len(), self.buffer.len());
+            buf[..to_copy].copy_from_slice(&self.buffer[..to_copy]);
+            self.buffer.drain(..to_copy);
+            Ok(to_copy)
+        }
+    }
+    pub struct AsyncStreamingCompressor<W: AsyncWrite + Unpin> {
+        writer: W,
+        encoder: Encoder<'static, Vec<u8>>,
+    }
+    impl<W: AsyncWrite + Unpin> AsyncStreamingCompressor<W> {
+        pub fn new(writer: W, level: impl Into<i32>) -> Result<Self> {
+            let params = CompressionParams::new(level);
+            let encoder = build_encoder(Vec::new(), &params, None)?;
+            Ok(Self { writer, encoder })
+        }
+        pub async fn write(&mut self, buf: &[u8]) -> Result<usize> {
+            self.encoder.write_all(buf).map_err(|e| ZstdError::Zstd(e.to_string()))?;
+            let compressed = std::mem::take(self.encoder.get_mut());
+            self.writer.write_all(&compressed).await.map_err(ZstdError::Io)?;
+            Ok(buf.len())
+        }
+        pub async fn flush(&mut self) -> Result<()> {
+            self.encoder.flush().map_err(|e| ZstdError::Zstd(e.to_string()))?;
+            let compressed = std::mem::take(self.encoder.get_mut());
+            self.writer.write_all(&compressed).await.map_err(ZstdError::Io)?;
+            self.writer.flush().await.map_err(ZstdError::Io)?;
+            Ok(())
+        }
+        pub async fn finish(mut self) -> Result<W> {
+            let compressed = self.encoder.finish().map_err(|e| ZstdError::Zstd(e.to_string()))?;
+            self.writer.write_all(&compressed).await.map_err(ZstdError::Io)?;
+            self.writer.flush().await.map_err(ZstdError::Io)?;
+            Ok(self.writer)
+        }
+    }
+    pub async fn compress_async(data: &[u8], level: impl Into<i32> + Send + 'static) -> Result<Vec<u8>> {
+        let data = data.to_vec();
+        let level = level.into();
+        tokio::task::spawn_blocking(move || compress(&data, level)).await.unwrap()
+    }
+    pub async fn decompress_async(data: &[u8]) -> Result<Vec<u8>> {
+        let data = data.to_vec();
+        tokio::task::spawn_blocking(move || decompress(&data)).await.unwrap()
+    }
+}
+pub fn estimate_compressed_size(data: &[u8], level: i32) -> usize {
+    let mut encoder = Encoder::new(Vec::new(), level).unwrap();
+    let _ = encoder.write(data);
+    let finished = encoder.finish().unwrap();
+    finished.len()
+}
+pub fn get_frame_info(data: &[u8]) -> Result<FrameInfo> {
+    if data.len() < 8 {
+        return Err(ZstdError::InvalidParam("Data too small for frame header".into()));
+    }
+    let magic = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
+    let dict_id = match magic {
+        0x28B52FED => {
+            if data.len() < 8 { return Err(ZstdError::InvalidParam("Invalid frame".into())); }
+            Some(u32::from_le_bytes([data[4], data[5], data[6], data[7]]))
+        }
+        0xFD2FB528 => {
+            if data.len() < 12 { return Err(ZstdError::InvalidParam("Invalid skippable frame".into())); }
+            Some(u32::from_le_bytes([data[8], data[9], data[10], data[11]]))
+        }
+        _ => return Err(ZstdError::InvalidParam("Not a valid zstd frame".into())),
+    };
+    Ok(FrameInfo { magic, dict_id })
+}
+#[derive(Debug, Clone)]
+pub struct FrameInfo {
+    pub magic: u32,
+    pub dict_id: Option<u32>,
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn roundtrip() {
+        let original = b"Hello, Zstandard! This is a test string for compression.";
+        let compressed = compress(original, 3).unwrap();
+        let decompressed = decompress(&compressed).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+    #[test]
+    fn roundtrip_with_params() {
+        let original = b"Testing compression with custom params ".repeat(50);
+        let params = CompressionParams::new(6)
+            .with_checksum(true)
+            .with_content_size(true);
+        let compressed = compress_with_params(&original, &params, None).unwrap();
+        let decompressed = decompress(&compressed).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+    #[test]
+    fn multithread_compression() {
+        let original = b"Multi-threaded compression test ".repeat(1000);
+        let params = CompressionParams::new(3).with_threads(4);
+        let compressed = compress_with_params(&original, &params, None).unwrap();
+        let decompressed = decompress(&compressed).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+        assert!(compressed.len() < original.len());
+    }
+    #[test]
+    fn dictionary_roundtrip() {
+        let dict_data = b"common prefix data that repeats often in our dataset ";
+        let dict = Dictionary::new(dict_data.to_vec()).unwrap();
+        let original = b"common prefix data that repeats often in our dataset - unique part 1";
+        let compressed = compress_with_dict(original, 3, &dict).unwrap();
+        let decompressed = decompress_with_dict(&compressed, &dict).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+    #[test]
+    fn streaming_compressor() {
+        let original = b"Streaming compression test ".repeat(50);
+        let mut compressed = Vec::new();
+        {
+            let mut compressor = StreamingCompressor::new(&mut compressed, 3).unwrap();
+            compressor.write(&original[..200]).unwrap();
+            compressor.write(&original[200..400]).unwrap();
+            compressor.write(&original[400..]).unwrap();
+            compressor.finish().unwrap();
+        }
+        let decompressed = decompress(&compressed).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+    #[test]
+    fn frame_info() {
+        let original = b"Test data for frame info";
+        let compressed = compress(original, 3).unwrap();
+        let info = get_frame_info(&compressed).unwrap();
+        assert_eq!(info.magic, 0xFD2FB528); // Skippable frame magic
+        assert!(info.dict_id.is_some());
+    }
+    #[test]
+    fn checksum_verification() {
+        let original = b"Data with checksum";
+        let compressed = compress(original, 3).unwrap();
+        let decompressed = decompress_verify_checksum(&compressed).unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+    #[test]
+    fn compression_level_enum() {
+        let original = b"Test data for compression level enum ".repeat(100);
+        let compressed_default = compress(&original, CompressionLevel::Default).unwrap();
+        let compressed_best = compress(&original, CompressionLevel::Best).unwrap();
+        let compressed_fastest = compress(&original, CompressionLevel::Fastest).unwrap();
+        assert!(compressed_best.len() <= compressed_default.len());
+        assert!(compressed_default.len() <= compressed_fastest.len());
+        for compressed in [compressed_default, compressed_best, compressed_fastest] {
+            let decompressed = decompress(&compressed).unwrap();
+            assert_eq!(original.to_vec(), decompressed);
+        }
+    }
+    #[cfg(feature = "async")]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn async_compress_decompress() {
+        let original = b"Async compression test ".repeat(100);
+        let compressed = async_api::compress_async(&original, 3).await.unwrap();
+        let decompressed = async_api::decompress_async(&compressed).await.unwrap();
+        assert_eq!(original.to_vec(), decompressed);
+    }
+}
+#[cfg(feature = "python")]
+mod python;

zxtd-0.1.0/src/python.rs ADDED Viewed

@@ -0,0 +1,251 @@
+#[cfg(feature = "python")]
+use pyo3::prelude::*;
+#[cfg(feature = "python")]
+use pyo3::types::{PyBytes, PyDict, PyList};
+#[cfg(feature = "python")]
+use std::io::Cursor;
+#[cfg(feature = "python")]
+use crate::{
+    compress, compress_with_dict, compress_with_params, decompress, decompress_with_dict,
+    decompress_verify_checksum, estimate_compressed_size, get_frame_info,
+    CompressionParams, CompressionLevel, Dictionary, FrameInfo, ZstdError,
+};
+#[cfg(feature = "python")]
+#[pyclass(name = "CompressionParams")]
+struct PyCompressionParams {
+    inner: CompressionParams,
+}
+#[cfg(feature = "python")]
+#[pymethods]
+impl PyCompressionParams {
+    #[new]
+    #[pyo3(signature = (level = 3))]
+    fn new(level: i32) -> Self {
+        Self { inner: CompressionParams::new(level) }
+    }
+    #[staticmethod]
+    fn from_level(level: i32) -> Self {
+        Self { inner: CompressionParams::new(level) }
+    }
+    fn with_threads(&mut self, threads: u32) -> PyResult<()> {
+        self.inner = self.inner.clone().with_threads(threads);
+        Ok(())
+    }
+    fn with_checksum(&mut self, enable: bool) -> PyResult<()> {
+        self.inner = self.inner.clone().with_checksum(enable);
+        Ok(())
+    }
+    fn with_content_size(&mut self, enable: bool) -> PyResult<()> {
+        self.inner = self.inner.clone().with_content_size(enable);
+        Ok(())
+    }
+    fn with_dict_id(&mut self, enable: bool) -> PyResult<()> {
+        self.inner = self.inner.clone().with_dict_id(enable);
+        Ok(())
+    }
+    fn __repr__(&self) -> String {
+        format!("CompressionParams(level={}, threads={}, checksum={})",
+                self.inner.level, self.inner.threads, self.inner.checksum)
+    }
+}
+#[cfg(feature = "python")]
+#[pyclass(name = "Dictionary")]
+struct PyDictionary {
+    inner: Dictionary,
+}
+#[cfg(feature = "python")]
+#[pymethods]
+impl PyDictionary {
+    #[new]
+    fn new(data: &[u8]) -> PyResult<Self> {
+        Ok(Self { inner: Dictionary::new(data.to_vec())? })
+    }
+    #[staticmethod]
+    fn from_bytes(data: &[u8]) -> PyResult<Self> {
+        Ok(Self { inner: Dictionary::from_bytes(data)? })
+    }
+    #[staticmethod]
+    fn detect_dict_id(data: &[u8]) -> PyResult<Option<u32>> {
+        Ok(Dictionary::detect_dict_id_from_frame(data))
+    }
+    fn as_bytes(&self) -> &[u8] {
+        self.inner.as_bytes()
+    }
+    fn __len__(&self) -> usize {
+        self.inner.len()
+    }
+    fn __repr__(&self) -> String {
+        format!("Dictionary(len={})", self.inner.len())
+    }
+}
+#[cfg(feature = "python")]
+#[pyclass(name = "FrameInfo")]
+struct PyFrameInfo {
+    inner: FrameInfo,
+}
+#[cfg(feature = "python")]
+#[pymethods]
+impl PyFrameInfo {
+    #[getter]
+    fn magic(&self) -> u32 {
+        self.inner.magic
+    }
+    #[getter]
+    fn dict_id(&self) -> Option<u32> {
+        self.inner.dict_id
+    }
+    fn __repr__(&self) -> String {
+        format!("FrameInfo(magic=0x{:x}, dict_id={:?})", self.inner.magic, self.inner.dict_id)
+    }
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(signature = (data, level = 3), name = "compress")]
+fn compress_py(data: &[u8], level: i32) -> PyResult<PyObject> {
+    let compressed = compress(data, level)?;
+    Python::with_gil(|py| Ok(PyBytes::new(py, &compressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(signature = (data, level = 3, dict = None), name = "compress_with_dict")]
+fn compress_with_dict_py(data: &[u8], level: i32, dict: Option<&PyDictionary>) -> PyResult<PyObject> {
+    let compressed = if let Some(d) = dict {
+        compress_with_dict(data, level, &d.inner)?
+    } else {
+        compress(data, level)?
+    };
+    Python::with_gil(|py| Ok(PyBytes::new(py, &compressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(signature = (data, params, dict = None), name = "compress_with_params")]
+fn compress_with_params_py(data: &[u8], params: &PyCompressionParams, dict: Option<&PyDictionary>) -> PyResult<PyObject> {
+    let compressed = if let Some(d) = dict {
+        compress_with_params(data, &params.inner, Some(&d.inner))?
+    } else {
+        compress_with_params(data, &params.inner, None)?
+    };
+    Python::with_gil(|py| Ok(PyBytes::new(py, &compressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "decompress")]
+fn decompress_py(data: &[u8]) -> PyResult<PyObject> {
+    let decompressed = decompress(data)?;
+    Python::with_gil(|py| Ok(PyBytes::new(py, &decompressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(signature = (data, dict = None), name = "decompress_with_dict")]
+fn decompress_with_dict_py(data: &[u8], dict: Option<&PyDictionary>) -> PyResult<PyObject> {
+    let decompressed = if let Some(d) = dict {
+        decompress_with_dict(data, &d.inner)?
+    } else {
+        decompress(data)?
+    };
+    Python::with_gil(|py| Ok(PyBytes::new(py, &decompressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "decompress_verify")]
+fn decompress_verify_py(data: &[u8]) -> PyResult<PyObject> {
+    let decompressed = decompress_verify_checksum(data)?;
+    Python::with_gil(|py| Ok(PyBytes::new(py, &decompressed).into()))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "estimate_size")]
+fn estimate_size_py(data: &[u8], level: i32) -> PyResult<usize> {
+    Ok(estimate_compressed_size(data, level))
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "frame_info")]
+fn frame_info_py(data: &[u8]) -> PyResult<PyFrameInfo> {
+    Ok(PyFrameInfo { inner: get_frame_info(data)? })
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "compression_levels")]
+fn compression_levels() -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("FASTEST", CompressionLevel::Fastest as i32)?;
+        dict.set_item("FAST", CompressionLevel::Fast as i32)?;
+        dict.set_item("DEFAULT", CompressionLevel::Default as i32)?;
+        dict.set_item("BETTER", CompressionLevel::Better as i32)?;
+        dict.set_item("BEST", CompressionLevel::Best as i32)?;
+        dict.set_item("ULTRA", CompressionLevel::Ultra as i32)?;
+        Ok(dict.into())
+    })
+}
+#[cfg(feature = "python")]
+#[pyfunction]
+#[pyo3(name = "strategies")]
+fn strategies() -> PyResult<PyObject> {
+    Python::with_gil(|py| {
+        let list = PyList::new(py, &[
+            "FAST", "DFAST", "GREEDY", "LAZY", "LAZY2",
+            "BTLZ2", "BTOPT", "BTULTRA", "BTULTRA2"
+        ])?;
+        Ok(list.into())
+    })
+}
+#[cfg(feature = "python")]
+#[pymodule]
+fn zxtd(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<PyCompressionParams>()?;
+    m.add_class::<PyDictionary>()?;
+    m.add_class::<PyFrameInfo>()?;
+    m.add_function(wrap_pyfunction!(compress_py, m)?)?;
+    m.add_function(wrap_pyfunction!(compress_with_dict_py, m)?)?;
+    m.add_function(wrap_pyfunction!(compress_with_params_py, m)?)?;
+    m.add_function(wrap_pyfunction!(decompress_py, m)?)?;
+    m.add_function(wrap_pyfunction!(decompress_with_dict_py, m)?)?;
+    m.add_function(wrap_pyfunction!(decompress_verify_py, m)?)?;
+    m.add_function(wrap_pyfunction!(estimate_size_py, m)?)?;
+    m.add_function(wrap_pyfunction!(frame_info_py, m)?)?;
+    m.add_function(wrap_pyfunction!(compression_levels, m)?)?;
+    m.add_function(wrap_pyfunction!(strategies, m)?)?;
+    Ok(())
+}
+#[cfg(feature = "python")]
+impl From<ZstdError> for PyErr {
+    fn from(err: ZstdError) -> PyErr {
+        PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(err.to_string())
+    }
+}