Apple-Compress

0.2.3 · active · verified Thu Apr 16

apple-compress provides Python bindings for Apple's native libcompression framework. This library allows Python applications to utilize the highly optimized compression and decompression algorithms available on Apple operating systems (macOS, iOS, etc.). As of April 2026, the current version is 0.2.3. The release cadence is infrequent, typically aligned with bug fixes or minor enhancements rather than a strict schedule.

Common errors

```
ModuleNotFoundError: No module named 'apple_compress'
```
cause The `apple-compress` package is not installed in the current Python environment.

fix Run `pip install apple-compress` to install the library.
```
AttributeError: module 'apple_compress' has no attribute 'compress' (or 'LZFSE')
```
cause Incorrect import or calling non-existent function/attribute, possibly due to misunderstanding the API or a non-standard installation.

fix Verify the correct import paths and function names by checking the library's source code on GitHub or by experimenting in a Python shell. The most common functions are `compress` and `decompress` and algorithms `LZFSE`, `ZLIB`.
```
RuntimeError: Compression failed: -1 (or similar native library error code)
```
cause This error typically indicates an issue with the underlying Apple `libcompression` framework, such as an invalid algorithm, corrupted data, or a platform-specific issue, often occurring when run on a non-Apple OS.

fix Ensure the code is running on an Apple operating system. Double-check the `algorithm` parameter passed to `compress` or `decompress` functions. Inspect the input data for corruption. If the issue persists, consult Apple's `libcompression` documentation for error code meanings.

Warnings

breaking This library is designed for and only functions on Apple operating systems (macOS, iOS, watchOS, tvOS). Attempting to use it on Linux, Windows, or other non-Apple platforms will result in runtime errors due to missing native 'libcompression' functionality.
Fix: Ensure deployment environment is an Apple OS. For cross-platform compression, consider `zlib`, `lzma`, or `gzip` from the Python standard library, or other third-party libraries like `python-lz4`.
gotcha The official GitHub README links to a 'Library API Usage' wiki page which does not exist or is not publicly accessible. Users need to infer API usage from source code or examples.
Fix: Refer to the provided quickstart and potentially examine the library's source code on GitHub for specific function signatures and available algorithms beyond the common LZFSE and ZLIB. Common functions are `compress(data, algorithm)` and `decompress(data, algorithm)`.
gotcha The available compression algorithms are dictated by Apple's `libcompression` and may vary slightly or have different performance characteristics across various Apple OS versions. Always test on your target OS version.
Fix: The library typically provides constants (e.g., `apple_compress.LZFSE`, `apple_compress.ZLIB`) for supported algorithms. Use these constants and test algorithm performance/compatibility on your specific macOS/iOS versions.

Install

pip install apple-compress Install from PyPI

Imports

compress
```
from apple_compress import compress
```
Main function for data compression.
decompress
```
from apple_compress import decompress
```
Main function for data decompression.
LZFSE
```
from apple_compress import LZFSE
```
Represents the LZFSE compression algorithm, one of several supported.
ZLIB
```
from apple_compress import ZLIB
```
Represents the ZLIB compression algorithm.

Quickstart

This quickstart demonstrates how to compress and decompress a byte string using the LZFSE algorithm. The library typically exposes `compress` and `decompress` functions along with algorithm constants like `LZFSE` or `ZLIB`.

import apple_compress

original_data = b"This is some data to be compressed by apple-compress using LZFSE!"
print(f"Original data length: {len(original_data)} bytes")

# Compress data using the LZFSE algorithm
compressed_data = apple_compress.compress(original_data, algorithm=apple_compress.LZFSE)
print(f"Compressed data length: {len(compressed_data)} bytes")
print(f"Compressed data (first 50 bytes): {compressed_data[:50]}...")

# Decompress data using the same algorithm
decompressed_data = apple_compress.decompress(compressed_data, algorithm=apple_compress.LZFSE)
print(f"Decompressed data length: {len(decompressed_data)} bytes")

assert original_data == decompressed_data
print("Decompression successful! Original and decompressed data match.")

view raw JSON →