LZNT1

https://github.com/you0708/lznt1
Admin
LZNT1 is a Python module for compression and decompression using the LZNT1 algorithm, compatible...
Tokens:2,020
Snippets:17
Trust Score:6.6
License:Apache-2.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install LZNT1 library

Source: https://github.com/you0708/lznt1/blob/master/README.md

Use pip to install the package.

```bash
pip install lznt1
```

--------------------------------

### Decompress LZNT1 Data from Windows

Source: https://context7.com/you0708/lznt1/llms.txt

Use this snippet to decompress data that was originally compressed using Windows' LZNT1 algorithm. Ensure the 'lznt1' library is installed and imported.

```python
import lznt1

with open("from_windows.lznt1", "rb") as f:
    windows_compressed = f.read()
decompressed = lznt1.decompress(windows_compressed)
```

--------------------------------

### Compressing Data with LZNT1

Source: https://context7.com/you0708/lznt1/llms.txt

Demonstrates basic compression, custom chunk sizing, and file-based compression workflows.

```python
import lznt1

# Compress a simple string
data = b"Hello world! " * 100
compressed = lznt1.compress(data)

print(f"Original size: {len(data)} bytes")
print(f"Compressed size: {len(compressed)} bytes")
print(f"Compression ratio: {len(compressed) / len(data):.2%}")

# Output:
# Original size: 1300 bytes
# Compressed size: 38 bytes
# Compression ratio: 2.92%

# Compress with custom chunk size
compressed_small_chunks = lznt1.compress(data, chunk_size=0x800)

# Compress file contents
with open("document.txt", "rb") as f:
    file_data = f.read()
compressed_file = lznt1.compress(file_data)

# Write compressed data to file
with open("document.txt.compressed", "wb") as f:
    f.write(compressed_file)
```

--------------------------------

### Preparing Data for Windows Interoperability

Source: https://context7.com/you0708/lznt1/llms.txt

Shows how to compress data in Python for consumption by the native Windows RtlDecompressBuffer API.

```python
import lznt1

# Compress data for Windows consumption
data = b"Cross-platform compressed data" * 100
compressed = lznt1.compress(data)

# Save for Windows system to decompress with RtlDecompressBuffer
with open("for_windows.lznt1", "wb") as f:
    f.write(compressed)
```

--------------------------------

### Run Library Tests

Source: https://github.com/you0708/lznt1/blob/master/README.md

Execute the test script to verify compression and decompression integrity.

```bash
C:\Users\you\Desktop>python test.py lznt1.py
[*] input size = 4034 bytes, sha1 hash = e19250d48c1e46d7d0fa46a5d345487d723559cd
[*] size of compressed1: 1264
[*] size of compressed2: 1559
[*] sha1 hash of compressed1: 720bd5775ee3273deaebabb29a412ea079fa79ae
[*] sha1 hash of compressed2: 8df2fe59dba7fa4d4d01a8f12f05d7b5799238cc
[*] sha1 hash of decompressed11: e19250d48c1e46d7d0fa46a5d345487d723559cd
[*] sha1 hash of decompressed12: e19250d48c1e46d7d0fa46a5d345487d723559cd
[*] sha1 hash of decompressed21: e19250d48c1e46d7d0fa46a5d345487d723559cd
[*] sha1 hash of decompressed22: e19250d48c1e46d7d0fa46a5d345487d723559cd
```

--------------------------------

### Verify Windows RtlDecompressBuffer Interoperability

Source: https://context7.com/you0708/lznt1/llms.txt

This Python code demonstrates how to verify interoperability with Windows' `RtlDecompressBuffer` function using `ctypes`. It's useful for testing if the Python library produces byte-compatible output with the native Windows API.

```python
import ctypes
buf = ctypes.create_string_buffer(len(data) * 2)
final_size = ctypes.c_ulong(0)
ctypes.windll.ntdll.RtlDecompressBuffer(
    2,  # COMPRESSION_FORMAT_LZNT1
    buf, ctypes.sizeof(buf),
    ctypes.c_char_p(compressed), len(compressed),
    ctypes.byref(final_size)
)
windows_decompressed = buf.raw[:final_size.value]
```

--------------------------------

### Decompressing Data with LZNT1

Source: https://context7.com/you0708/lznt1/llms.txt

Covers basic decompression, handling file streams, and managing length validation for potentially corrupted data.

```python
import lznt1

# Basic decompression
original_data = b"The quick brown fox jumps over the lazy dog. " * 50
compressed = lznt1.compress(original_data)
decompressed = lznt1.decompress(compressed)

assert decompressed == original_data
print(f"Decompression successful: {len(decompressed)} bytes recovered")

# Output:
# Decompression successful: 2250 bytes recovered

# Decompress data from file
with open("document.txt.compressed", "rb") as f:
    compressed_data = f.read()
decompressed_data = lznt1.decompress(compressed_data)

# Disable length check for potentially truncated data
try:
    result = lznt1.decompress(compressed_data, length_check=True)
except ValueError as e:
    print(f"Decompression error: {e}")
    # Retry without length check for partial recovery
    result = lznt1.decompress(compressed_data, length_check=False)

# Decompress Windows NTFS compressed file streams
def read_ntfs_compressed_stream(compressed_bytes):
    """Decompress data from NTFS compressed file."""
    return lznt1.decompress(compressed_bytes)
```

--------------------------------

### Compress and Decompress Data

Source: https://github.com/you0708/lznt1/blob/master/README.md

Basic usage for compressing and decompressing byte data.

```python
>>> import lznt1
>>> compressed = lznt1.compress(data)
>>> decompressed = lznt1.decompress(compressed)
```

--------------------------------

### Verifying Data Integrity with Round-trip Compression

Source: https://context7.com/you0708/lznt1/llms.txt

Uses SHA1 hashing to verify that data remains unchanged after a full compression and decompression cycle.

```python
import lznt1
from hashlib import sha1

def compress_and_verify(data):
    """Compress data and verify round-trip integrity."""
    original_hash = sha1(data).hexdigest()
    print(f"Original: {len(data)} bytes, SHA1: {original_hash}")

    # Compress
    compressed = lznt1.compress(data)
    compressed_hash = sha1(compressed).hexdigest()
    print(f"Compressed: {len(compressed)} bytes, SHA1: {compressed_hash}")

    # Decompress
    decompressed = lznt1.decompress(compressed)
    decompressed_hash = sha1(decompressed).hexdigest()
    print(f"Decompressed: {len(decompressed)} bytes, SHA1: {decompressed_hash}")

    # Verify integrity
    if original_hash == decompressed_hash:
        print("Verification: PASSED")
        return True
    else:
        print("Verification: FAILED")
        return False

# Test with various data types
test_data = b"AAABBBCCCDDDEEE" * 1000
compress_and_verify(test_data)

# Output:
# Original: 15000 bytes, SHA1: 7a4c8f...
# Compressed: 89 bytes, SHA1: 3b2e1a...
# Decompressed: 15000 bytes, SHA1: 7a4c8f...
# Verification: PASSED

# Process binary file
with open("binary_file.bin", "rb") as f:
    binary_data = f.read()
compress_and_verify(binary_data)
```
Tokens:
Raw